chore: now the compiler is happy

Author: mabels

src/api-core.ts

@@ -12,6 +12,9 @@ import {
   isToolUseType,
   isToolUseResponse,
   isOpenAIArray,
+  OpenAIFunctionCall,
+  RequestSchema,
+  CallAIError,
 } from "./types.js";
 import { globalDebug } from "./key-management.js";
 import { callAINonStreaming } from "./non-streaming.js";
@@ -41,7 +44,9 @@ function callAi(prompt: string | Message[], options: CallAIOptions = {}) {
   let schemaStrategy: SchemaStrategy = {
     strategy: "none" as const,
     model: options.model || "openai/gpt-3.5-turbo",
-    prepareRequest: () => (undefined),
+    prepareRequest: () => {
+      throw new Error("Schema strategy not implemented");
+    },
     processResponse: (response) => {
       // If response is an object, stringify it to match expected test output
       if (response && typeof response === "object") {
@@ -67,16 +72,12 @@ function callAi(prompt: string | Message[], options: CallAIOptions = {}) {
         shouldForceStream: false,
         prepareRequest: (schema) => {
           // Parse the schema to extract the function definition
-          let toolDef: {
-            name?: string;
-            description?: string;
-            parameters?: unknown;
-          } = {};
+          let toolDef: Partial<RequestSchema> = {};
 
           if (typeof schema === "string") {
             try {
               toolDef = JSON.parse(schema);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
             } catch (e) {
               // If it's not valid JSON, we'll use it as a plain description
               toolDef = { description: schema };
@@ -97,7 +98,7 @@ function callAi(prompt: string | Message[], options: CallAIOptions = {}) {
                   properties: {},
                 },
               },
-            },
+            } satisfies OpenAIFunctionCall,
           ];
 
           return {
@@ -149,7 +150,7 @@ function callAi(prompt: string | Message[], options: CallAIOptions = {}) {
         shouldForceStream: false,
         prepareRequest: (schema) => {
           // Create a properly formatted JSON schema request
-          const schemaObj = (schema as Schema) || {};
+          const schemaObj: Partial<Schema> = schema || {};
           return {
             response_format: {
               type: "json_schema",
@@ -200,7 +201,6 @@ function callAi(prompt: string | Message[], options: CallAIOptions = {}) {
     })();
 
     // Create a proxy object that acts both as a Promise and an AsyncGenerator for backward compatibility
-    // @ts-ignore - We're deliberately implementing a proxy with dual behavior
     return createBackwardCompatStreamingProxy(streamPromise);
   } else {
     if (debug) {
@@ -239,17 +239,21 @@ async function bufferStreamingResults(
   } catch (error) {
     // If we already collected some content, attach it to the error
     if (error instanceof Error) {
-      const enhancedError = new Error(
-        `${error.message} (Partial content: ${result.slice(0, 100)}...)`,
-      );
-      (enhancedError as any).partialContent = result;
-      (enhancedError as any).originalError = error;
+      const enhancedError = new CallAIError({
+        message: `${error.message} (Partial content: ${result.slice(0, 100)}...)`,
+        status: 511,
+        partialContent: result,
+        originalError: error,
+      });
       throw enhancedError;
     } else {
       // For non-Error objects, create an Error with info
-      const newError = new Error(`Streaming error: ${String(error)}`);
-      (newError as any).partialContent = result;
-      (newError as any).originalError = error;
+      const newError = new CallAIError({
+        message: `Streaming error: ${String(error)}`,
+        status: 511,
+        partialContent: result,
+        originalError: error as Error,
+      });
       throw newError;
     }
   }
@@ -263,7 +267,7 @@ function createBackwardCompatStreamingProxy(
   promise: Promise<StreamResponse>,
 ): ThenableStreamResponse {
   // Create a proxy that forwards methods to the Promise or AsyncGenerator as appropriate
-  return new Proxy({} as any, {
+  return new Proxy({} as ThenableStreamResponse, {
     get(_target, prop) {
       // First check if it's an AsyncGenerator method (needed for for-await)
       if (
@@ -277,7 +281,7 @@ function createBackwardCompatStreamingProxy(
           return function () {
             return {
               // Implement async iterator that gets the generator first
-              async next(value?: unknown) {
+              async next(value: unknown) {
                 try {
                   const generator = await promise;
                   return generator.next(value);
@@ -291,9 +295,18 @@ function createBackwardCompatStreamingProxy(
         }
 
         // Methods like next, throw, return
-        return async function (value?: unknown) {
+        return async function (value: unknown) {
           const generator = await promise;
-          return (generator as any)[prop](value);
+          switch (prop) {
+            case "next":
+              return generator.next(value);
+            case "throw":
+              return generator.throw(value);
+            case "return":
+              return generator.return(value as string);
+            default:
+              throw new Error(`Unknown method: ${String(prop)}`);
+          }
         };
       }
 
@@ -319,7 +332,7 @@ function prepareRequestParams(
   options: CallAIOptions = {},
 ) {
   // Get API key from options or window.CALLAI_API_KEY (exactly matching original)
-  const apiKey = options.apiKey || callAiEnv.CALLAI_API_KEY
+  const apiKey = options.apiKey || callAiEnv.CALLAI_API_KEY;
 
   // Validate API key with original error message
   if (!apiKey) {

src/api.ts

@@ -3,6 +3,7 @@
  */
 import {
   CallAIError,
+  CallAIErrorParams,
   CallAIOptions,
   Message,
   ResponseMeta,
@@ -39,7 +40,6 @@ import { callAiEnv } from "./utils.js";
 // export { getMeta };
 
 // Import package version for debugging
- 
 
 // Default fallback model when the primary model fails or is unavailable
 const FALLBACK_MODEL = "openrouter/auto";
@@ -260,7 +260,7 @@ export function callAi(
             statusText: response.statusText,
             details: errorJson,
             contentType,
-          })
+          });
           throw error;
         } catch (jsonError) {
           // If JSON parsing fails, extract a useful message from the raw error body
@@ -303,7 +303,7 @@ export function callAi(
             statusText: response.statusText,
             details: errorBody,
             contentType,
-          })
+          });
           throw error;
         }
       } catch (responseError) {
@@ -313,14 +313,13 @@ export function callAi(
         }
 
         // Fallback error
-        const error = new CallAIError(
-          {
-            message: `API returned ${response.status}: ${response.statusText}`,
-            status: response.status,
-            statusText: response.statusText,
-            details: undefined,
-            contentType,
-          })
+        const error = new CallAIError({
+          message: `API returned ${response.status}: ${response.statusText}`,
+          status: response.status,
+          statusText: response.statusText,
+          details: undefined,
+          contentType,
+        });
         throw error;
       }
     }
@@ -391,13 +390,18 @@ async function bufferStreamingResults(
     }
   } catch (error) {
     // Handle errors with standard API error handling
-    await handleApiError(error, "Buffered streaming", options.debug, {
-      apiKey: options.apiKey,
-      endpoint: options.endpoint,
-      skipRefresh: options.skipRefresh,
-      refreshToken: options.refreshToken,
-      updateRefreshToken: options.updateRefreshToken,
-    });
+    await handleApiError(
+      error as CallAIErrorParams,
+      "Buffered streaming",
+      options.debug,
+      {
+        apiKey: options.apiKey,
+        endpoint: options.endpoint,
+        skipRefresh: options.skipRefresh,
+        refreshToken: options.refreshToken,
+        updateRefreshToken: options.updateRefreshToken,
+      },
+    );
     // If we get here, key was refreshed successfully, retry the operation with the new key
     // Retry with the refreshed key
     return bufferStreamingResults(prompt, {
@@ -420,7 +424,6 @@ async function bufferStreamingResults(
 
 // checkForInvalidModelError is imported from error-handling.ts
 
-
 /**
  * Prepare request parameters common to both streaming and non-streaming calls
  */
@@ -436,8 +439,7 @@ function prepareRequestParams(
 } {
   // First try to get the API key from options or window globals
   const apiKey =
-    options.apiKey ||
-    keyStore.current || callAiEnv.CALLAI_API_KEY() // Try keyStore first in case it was refreshed in a previous call
+    options.apiKey || keyStore.current || callAiEnv.CALLAI_API_KEY(); // Try keyStore first in case it was refreshed in a previous call
   const schema = options.schema || null;
 
   // If no API key exists, we won't throw immediately. We'll continue and let handleApiError
@@ -600,7 +602,7 @@ async function callAINonStreaming(
         statusText: response.statusText,
         details: undefined,
         contentType: "text/plain",
-      })
+      });
       throw error;
     }
 
@@ -612,7 +614,7 @@ async function callAINonStreaming(
         result = await extractClaudeResponse(response);
       } catch (error) {
         handleApiError(
-          error,
+          error as CallAIErrorParams,
           "Claude API response processing failed",
           options.debug,
         );

src/error-handling.ts

@@ -15,7 +15,7 @@ import { CallAIError, CallAIErrorParams } from "./types.js";
 // @param debug Whether to log debug information
 // @param options Options for error handling including key refresh control
 async function handleApiError(
-  error: CallAIErrorParams,
+  ierror: unknown,
   context: string,
   debug: boolean = globalDebug,
   options: {
@@ -26,6 +26,8 @@ async function handleApiError(
     updateRefreshToken?: (currentToken: string) => Promise<string>;
   } = {},
 ): Promise<void> {
+  const error = ierror as CallAIErrorParams;
+
   // Extract error details
   const errorMessage = error?.message || String(error);
   const status =
@@ -171,23 +173,25 @@ async function handleApiError(
         );
       }
       // Create a more detailed error from the original one
-      const detailedError = new CallAIError( {
-          message: `${errorMessage} (Key refresh failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)})`,
-          originalError: error,
-          refreshError: refreshError,
-          status: status || 401
-      })
+      const detailedError = new CallAIError({
+        message: `${errorMessage} (Key refresh failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)})`,
+        originalError: error,
+        refreshError,
+        status: status || 401,
+        contentType: "text/plain",
+      });
 
       throw detailedError;
     }
   }
 
   // For non-key errors, create a detailed error object
-  const detailedError = new Error(`${context}: ${errorMessage}`);
-  (detailedError as any).originalError = error;
-  (detailedError as any).status = status || 500;
-  (detailedError as any).errorType = error?.name || "Error";
-
+  const detailedError = new CallAIError({
+    message: `${context}: ${errorMessage}`,
+    originalError: error,
+    status: status || 500,
+    errorType: error.name || "Error",
+  });
   throw detailedError;
 }
 
@@ -196,7 +200,7 @@ async function checkForInvalidModelError(
   response: Response,
   model: string,
   debug: boolean = globalDebug,
-): Promise<{ isInvalidModel: boolean; errorData?: any }> {
+): Promise<{ isInvalidModel: boolean; errorData?: unknown }> {
   // Only check 4xx errors (which could indicate invalid model)
   if (response.status < 400 || response.status >= 500) {
     return { isInvalidModel: false };
@@ -209,12 +213,14 @@ async function checkForInvalidModelError(
   let errorData;
   try {
     errorData = await responseClone.json();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (e) {
     // If it's not JSON, get the text
     try {
       const text = await responseClone.text();
       errorData = { error: text };
-    } catch (textError) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (e) {
       errorData = { error: `Error ${response.status}: ${response.statusText}` };
     }
   }

src/image.ts

@@ -7,7 +7,6 @@ import { callAiEnv } from "./utils.js";
 import { PACKAGE_VERSION } from "./version.js";
 
 // Import package version for debugging (same as main API)
- 
 
 /**
  * Generate images using a custom API that mimics OpenAI's image generation capabilities
@@ -34,7 +33,7 @@ export async function imageGen(
   }
 
   // Get custom origin if set
-  const customOrigin = options.imgUrl || callAiEnv.CALLAI_IMG_URL 
+  const customOrigin = options.imgUrl || callAiEnv.CALLAI_IMG_URL;
 
   try {
     // Handle image generation

src/index.ts

@@ -6,7 +6,7 @@
 export * from "./types.js";
 
 // Export API functions
-export { callAi, } from "./api.js";
+export { callAi } from "./api.js";
 // Backward compatibility for callAI (uppercase AI)
 export { callAi as callAI } from "./api.js";