commit d8b1870059b2c50ea1325c1a35d3af6b58b85611 · indexx.dev/bsky-alt-text-worker

+2

README.md

···

       3
       3
        
       A Cloudflare Worker which works in conjunction with https://github.com/indexxing/Bluesky-Alt-Text. All endpoints are based off the original cloud function made by [symmetricalboy](https://github.com/symmetricalboy) [here](https://github.com/symmetricalboy/gen-alt-text/blob/main/functions/index.js), just in Typescript and prepackaged into a Cloudflare Worker environment.

     

       4
       4
        
       

     

       5
       5
        
       Documentation is served at the root of the worker deployment. There is a root path variable specified in the entrypoint file because my setup involves using a worker route wildcard on my custom domain.

     

       6
       6
       +
       

     

       7
       7
       +
       **Note:** This does not support video captioning, or uploading larger media for processing yet like the source cloud function.

+11 -7

src/endpoints/condense_text.ts

···

       8
       8
        
       		summary: "Condense a given text based on a directive",

     

       9
       9
        
       		security: [

     

       10
       10
        
       			{

     

       11
       11
       -
       				apiKey: [],

     

       11
       11
       +
       				bearerAuth: [],

     

       12
       12
        
       			},

     

       13
       13
        
       		],

     

       14
       14
        
       		request: {

     
···

       67
       67
        
       

     

       68
       68
        
       		try {

     

       69
       69
        
       			const res = await c.var.gemini.models.generateContent({

     

       70
       70
       -
       				// * Original cloud function used "gemini-2.0-flash", but I think the lite version should work fine too.

     

       71
       71
       -
       				model: "gemini-2.0-flash-lite",

     

       70
       70
       +
       				model: c.env.GEMINI_MODEL,

     

       72
       71
        
       				contents: [{

     

       73
       72
        
       					parts: [

     

       74
       73
        
       						{

     
···

       79
       78
        
       					],

     

       80
       79
        
       				}],

     

       81
       80
        
       				config: {

     

       82
       82
       -
       					temperature: 0.2,

     

       83
       83
       -
       					maxOutputTokens: 1024,

     

       81
       81
       +
       					temperature: c.env.GEMINI_CONDENSE_TEMPERATURE,

     

       82
       82
       +
       					maxOutputTokens: c.env.GEMINI_CONDENSE_MAX_OUTPUT_TOKENS,

     

       84
       83
        
       				},

     

       85
       84
        
       			});

     

       86
       85
        
       

     

       87
       86
        
       			const condensedText = res.candidates?.[0]?.content?.parts?.[0]

     

       88
       87
        
       				?.text;

     

       89
       88
        
       			if (!condensedText) {

     

       89
       89
       +
       				c.status(502); // Bad response from upstream API resulting in "Bad Gateway" status

     

       90
       90
       +
       

     

       90
       91
        
       				return {

     

       91
       92
        
       					success: false,

     

       92
       93
        
       					error: "Failed to condense text.",

     
···

       95
       96
        
       

     

       96
       97
        
       			return {

     

       97
       98
        
       				success: true,

     

       98
       98
       -
       				altText: condensedText,

     

       99
       99
       +
       				text: condensedText,

     

       100
       100
       +
       				tokens: res.usageMetadata.totalTokenCount ?? 0,

     

       99
       101
        
       			};

     

       100
       102
        
       		} catch (e) {

     

       103
       103
       +
       			c.status(500);

     

       104
       104
       +
       

     

       101
       105
        
       			return {

     

       102
       106
        
       				success: false,

     

       103
       103
       -
       				message: e,

     

       107
       107
       +
       				error: e,

     

       104
       108
        
       			};

     

       105
       109
        
       		}

     

       106
       110
        
       	}

+9 -9

src/endpoints/generate.ts

···

       52
       52
        
               summary: "Generates alt text for a given image.",

     

       53
       53
        
               security: [

     

       54
       54
        
                   {

     

       55
       55
       -
                       apiKey: [],

     

       55
       55
       +
                       bearerAuth: [],

     

       56
       56
        
                   },

     

       57
       57
        
               ],

     

       58
       58
        
               request: {

     
···

       145
       145
        
       

     

       146
       146
        
               try {

     

       147
       147
        
                   const res = await c.var.gemini.models.generateContent({

     

       148
       148
       -
                       // * Original cloud function used "gemini-2.0-flash", but I think the lite version should work fine too.

     

       149
       149
       -
                       model: "gemini-2.0-flash-lite",

     

       148
       148
       +
                       model: c.env.GEMINI_MODEL,

     

       150
       149
        
                       contents: [

     

       151
       150
        
                           { text: systemInstructions },

     

       152
       151
        
                           { inlineData: { mimeType: mimeType, data: base64Data } },

     

       153
       152
        
                       ],

     

       154
       153
        
                       config: {

     

       155
       155
       -
                           temperature: 0.2, // Lower temperature for more deterministic output

     

       156
       156
       -
                           maxOutputTokens: 2048, // Allow for longer descriptions if needed

     

       157
       157
       -
                           topP: 0.95,

     

       158
       158
       -
                           topK: 64,

     

       154
       154
       +
                           temperature: c.env.GEMINI_GENERATE_TEMPERATURE,

     

       155
       155
       +
                           maxOutputTokens: c.env.GEMINI_GENERATE_MAX_OUTPUT_TOKENS,

     

       156
       156
       +
                           topP: c.env.GEMINI_GENERATE_TOP_P,

     

       157
       157
       +
                           topK: c.env.GEMINI_GENERATE_TOP_K,

     

       159
       158
        
                       },

     

       160
       159
        
                   });

     

       161
       160
        
       

     
···

       170
       169
        
       

     

       171
       170
        
                   return {

     

       172
       171
        
                       success: true,

     

       173
       173
       -
                       altText: generatedText,

     

       172
       172
       +
                       text: generatedText,

     

       173
       173
       +
                       tokens: res.usageMetadata.totalTokenCount ?? 0,

     

       174
       174
        
                   };

     

       175
       175
        
               } catch (e) {

     

       176
       176
        
                   return {

     

       177
       177
        
                       success: false,

     

       178
       178
       -
                       message: e,

     

       178
       178
       +
                       error: e,

     

       179
       179
        
                   };

     

       180
       180
        
               }

     

       181
       181
        
           }

+10 -19

src/index.ts

···

       16
       16
        
       app.use(

     

       17
       17
        
       	"*",

     

       18
       18
        
       	cors({

     

       19
       19
       -
       		origin: (origin) => {

     

       20
       20
       -
       			const allowedOrigins = [

     

       21
       21
       -
       				"https://indexx.dev",

     

       22
       22
       -
       				"moz-extension://",

     

       23
       23
       -
       				"chrome-extension://",

     

       24
       24
       -
       			];

     

       25
       25
       -
       

     

       26
       26
       -
       			if (

     

       27
       27
       -
       				origin &&

     

       28
       28
       -
       				allowedOrigins.some((allowed) => origin.startsWith(allowed))

     

       29
       29
       -
       			) {

     

       30
       30
       -
       				return origin;

     

       31
       31
       -
       			}

     

       32
       32
       -
       			return null;

     

       33
       33
       -
       		},

     

       19
       19
       +
       		origin: [

     

       20
       20
       +
       			"https://indexx.dev",

     

       21
       21
       +
       			"chrome-extension://",

     

       22
       22
       +
       			"safari-web-extension://",

     

       23
       23
       +
       			"moz-extension://",

     

       24
       24
       +
       		],

     

       34
       25
        
       		allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],

     

       35
       26
        
       		allowHeaders: ["*"],

     

       36
       27
        
       		maxAge: 600,

     
···

       51
       42
        
       	openapi_url: rootPath + "openapi.json",

     

       52
       43
        
       });

     

       53
       44
        
       

     

       54
       54
       -
       openapi.registry.registerComponent("securitySchemes", "apiKey", {

     

       55
       55
       -
       	type: "apiKey",

     

       56
       56
       -
       	name: "Authorization",

     

       57
       57
       -
       	in: "header",

     

       45
       45
       +
       openapi.registry.registerComponent("securitySchemes", "bearerAuth", {

     

       46
       46
       +
       	type: "http",

     

       47
       47
       +
       	scheme: "bearer",

     

       48
       48
       +
       	bearerFormat: "API key",

     

       58
       49
        
       });

     

       59
       50
        
       

     

       60
       51
        
       // Define Middlewares

+22 -9

src/middleware/auth.ts

···

       5
       5
        
           c: Context<{ Bindings: Env; Variables: Variables }>,

     

       6
       6
        
           next: Next,

     

       7
       7
        
       ) {

     

       8
       8
       +
           if (!c.env.AUTH_TOKEN) {

     

       9
       9
       +
               return c.json({

     

       10
       10
       +
                   success: false,

     

       11
       11
       +
                   error: "Authentication token is not specified in worker secrets.",

     

       12
       12
       +
               }, 500);

     

       13
       13
       +
           }

     

       14
       14
       +
       

     

       8
       15
        
           const authToken = c.req.header("Authorization");

     

       9
       16
        
       

     

       10
       10
       -
           if (!authToken) {

     

       11
       11
       -
               c.status(401);

     

       12
       12
       -
               return c.json({

     

       13
       13
       -
                   success: false,

     

       14
       14
       -
                   error: "No authentication token provided.",

     

       15
       15
       -
               });

     

       17
       17
       +
           if (!authToken || !authToken.startsWith("Bearer ")) {

     

       18
       18
       +
               return c.json(

     

       19
       19
       +
                   {

     

       20
       20
       +
                       success: false,

     

       21
       21
       +
                       error:

     

       22
       22
       +
                           "Authentication token missing or malformed. Expected 'Bearer <token>'.",

     

       23
       23
       +
                   },

     

       24
       24
       +
                   401,

     

       25
       25
       +
                   {

     

       26
       26
       +
                       "WWW-Authenticate": "Bearer",

     

       27
       27
       +
                   },

     

       28
       28
       +
               );

     

       16
       29
        
           }

     

       17
       30
        
       

     

       18
       18
       -
           if (authToken !== c.env.AUTH_TOKEN) {

     

       19
       19
       -
               c.status(403);

     

       31
       31
       +
           const token = authToken.split(" ")[1];

     

       32
       32
       +
           if (token !== c.env.AUTH_TOKEN) {

     

       20
       33
        
               return c.json({

     

       21
       34
        
                   success: false,

     

       22
       35
        
                   error: "Authentication token provided is invalid.",

     

       23
       23
       -
               });

     

       36
       36
       +
               }, 401);

     

       24
       37
        
           }

     

       25
       38
        
       

     

       26
       39
        
           await next();

+9 -10

src/types.ts

···

       1
       1
       -
       import { DateTime, Str } from "chanfana";

     

       2
       1
        
       import type { Context } from "hono";

     

       3
       3
       -
       import { z } from "zod";

     

       4
       2
        
       import type { GoogleGenAI } from "@google/genai";

     

       5
       3
        
       

     

       6
       4
        
       export type AppContext = Context<{ Bindings: Env; Variables: Variables }>;

     
···

       11
       9
        
       	ABSOLUTE_MAX_LENGTH: number;

     

       12
       10
        
       	MAX_DIRECT_BLOB_SIZE: number;

     

       13
       11
        
       

     

       12
       12
       +
       	GEMINI_MODEL: string;

     

       13
       13
       +
       	GEMINI_GENERATE_TEMPERATURE: number;

     

       14
       14
       +
       	GEMINI_GENERATE_MAX_OUTPUT_TOKENS: number;

     

       15
       15
       +
       	GEMINI_GENERATE_TOP_P: number;

     

       16
       16
       +
       	GEMINI_GENERATE_TOP_K: number;

     

       17
       17
       +
       

     

       18
       18
       +
       	GEMINI_CONDENSE_TEMPERATURE: number;

     

       19
       19
       +
       	GEMINI_CONDENSE_MAX_OUTPUT_TOKENS: number;

     

       20
       20
       +
       

     

       14
       21
        
       	// Secrets

     

       15
       22
        
       	AUTH_TOKEN: string;

     

       16
       23
        
       	GEMINI_API_KEY: string;

     
···

       19
       26
        
       export type Variables = {

     

       20
       27
        
       	gemini: GoogleGenAI;

     

       21
       28
        
       };

     

       22
       22
       -
       

     

       23
       23
       -
       export const Task = z.object({

     

       24
       24
       -
       	name: Str({ example: "lorem" }),

     

       25
       25
       -
       	slug: Str(),

     

       26
       26
       -
       	description: Str({ required: false }),

     

       27
       27
       -
       	completed: z.boolean().default(false),

     

       28
       28
       -
       	due_date: DateTime(),

     

       29
       29
       -
       });

+10 -1

wrangler.jsonc

···

       12
       12
        
         "vars": {

     

       13
       13
        
           "MAX_ALT_TEXT_LENGTH": 2000,

     

       14
       14
        
           "ABSOLUTE_MAX_LENGTH": 5000,

     

       15
       15
       -
           "MAX_DIRECT_BLOB_SIZE": 5242880

     

       15
       15
       +
           "MAX_DIRECT_BLOB_SIZE": 5242880,

     

       16
       16
       +
       

     

       17
       17
       +
           "GEMINI_MODEL": "gemini-2.0-flash-lite",

     

       18
       18
       +
           "GEMINI_GENERATE_TEMPERATURE": 0.2,

     

       19
       19
       +
           "GEMINI_GENERATE_MAX_OUTPUT_TOKENS": 2048,

     

       20
       20
       +
           "GEMINI_GENERATE_TOP_P": 0.95,

     

       21
       21
       +
           "GEMINI_GENERATE_TOP_K": 64,

     

       22
       22
       +
       

     

       23
       23
       +
           "GEMINI_CONDENSE_TEMPERATURE": 0.2,

     

       24
       24
       +
           "GEMINI_CONDENSE_MAX_OUTPUT_TOKENS": 1024

     

       16
       25
        
         }

     

       17
       26
        
       }