@aeye/models 0.2.0 → 0.3.1

package/package.json

@@ -1,52 +1,66 @@
-{
-  "name": "@aeye/models",
-  "version": "0.2.0",
-  "description": "Static model information scraped from OpenAI, OpenRouter, Replicate, and AWS Bedrock",
-  "type": "module",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "scrape": "tsx scripts/scrape.ts",
-    "scrape:openrouter": "tsx scripts/scrapers/openrouter.ts",
-    "scrape:openai": "tsx scripts/scrapers/openai.ts",
-    "scrape:replicate": "tsx scripts/scrapers/replicate.ts",
-    "scrape:replicate:next": "tsx scripts/scrapers/replicate.ts --transformers --n=1",
-    "scrape:aws": "tsx scripts/scrapers/aws.ts"
-  },
-  "keywords": ["ai", "models", "openai", "openrouter", "replicate", "aws", "bedrock"],
-  "author": "ClickerMonkey",
-  "license": "GPL-3.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ClickerMonkey/aeye.git",
-    "directory": "packages/models"
-  },
-  "dependencies": {
-    "@aeye/ai": "^0.1.0",
-    "@aeye/openrouter": "^0.1.0",
-    "@aeye/aws": "^0.1.0"
-  },
-  "devDependencies": {
-    "@aws-sdk/client-bedrock": "^3.709.0",
-    "@types/node": "^20.12.7",
-    "puppeteer": "^24.31.0",
-    "tsconfig-paths": "^4.2.0",
-    "tsx": "^4.7.0",
-    "typescript": "^5.9.3",
-    "axios": "^1.7.2",
-    "replicate": "^0.34.1"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "homepage": "https://github.com/ClickerMonkey/aeye#readme",
-  "bugs": {
-    "url": "https://github.com/ClickerMonkey/aeye/issues"
-  }
-}
+{
+  "name": "@aeye/models",
+  "version": "0.3.1",
+  "description": "Static model information scraped from OpenAI, OpenRouter, Replicate, and AWS Bedrock",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist tsconfig.tsbuildinfo",
+    "scrape": "tsx scripts/scrape.ts",
+    "scrape:openrouter": "tsx scripts/scrapers/openrouter.ts",
+    "scrape:openrouter:full": "tsx scripts/scrapers/openrouter.ts --metrics",
+    "scrape:openai": "tsx scripts/scrapers/openai.ts",
+    "scrape:replicate": "tsx scripts/scrapers/replicate.ts",
+    "scrape:replicate:test": "tsx scripts/scrapers/replicate.ts --transformers --transformers-only --models=\"adirik/kosmos-g\"",
+    "scrape:replicate:chunk": "tsx scripts/scrapers/replicate.ts --transformers --transformers-only --transformer-model=\"google/gemini-3-pro-preview\" --n=50 --transform-concurrency=0",
+    "scrape:replicate:models": "tsx scripts/scrapers/replicate.ts --transformers-only",
+    "scrape:replicate:patch": "tsx scripts/patch-modelinfo.ts",
+    "scrape:aws": "tsx scripts/scrapers/aws.ts"
+  },
+  "keywords": [
+    "ai",
+    "models",
+    "openai",
+    "openrouter",
+    "replicate",
+    "aws",
+    "bedrock"
+  ],
+  "author": "ClickerMonkey",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ClickerMonkey/aeye.git",
+    "directory": "packages/models"
+  },
+  "dependencies": {
+    "@aeye/ai": "0.3.1",
+    "@aeye/aws": "0.3.1",
+    "@aeye/openrouter": "0.3.1",
+    "@aeye/replicate": "0.3.1"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-bedrock": "^3.709.0",
+    "@types/node": "^20.12.7",
+    "axios": "^1.7.2",
+    "openapi-typescript": "^7.10.1",
+    "puppeteer": "^24.31.0",
+    "replicate": "^0.34.1",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "homepage": "https://github.com/ClickerMonkey/aeye#readme",
+  "bugs": {
+    "url": "https://github.com/ClickerMonkey/aeye/issues"
+  }
+}

package/scripts/codegen.ts

@@ -4,41 +4,42 @@
 
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import type { ModelInfo } from '@aeye/ai';
-
+import type { ModelInfo, ModelParameter } from '@aeye/ai';
+
+export const stringify = (x: any, space?: number | string | undefined) => 
+  (JSON.stringify(x, null, space) || '')
+    .replace(/"([^"]+)":/g, '$1:')
+    .replace(/\n/g, '\n  ')
+    .trim() || undefined;
+
+export const stringifyModel = (m: ModelInfo) => {
+  const fields: [any, string][] = [
+    [m.id, `id: '${m.id}'`],
+    [m.provider, `provider: '${m.provider}'`],
+    [m.name, `name: '${m.name}'`],
+    [m.contextWindow, `contextWindow: ${m.contextWindow}`],
+    [m.maxOutputTokens, `maxOutputTokens: ${m.maxOutputTokens}`],
+    [m.tier, `tier: '${m.tier}'`],
+    [m.tokenizer, `tokenizer: '${m.tokenizer}'`],
+    [m.capabilities, `capabilities: new Set([${Array.from(m.capabilities).map(c => `'${c}'`).join(', ')}])`],
+    [m.supportedParameters?.size || (m.supportedParameters as any)?.length, `supportedParameters: new Set([${Array.from(m.supportedParameters || []).map(p => `'${p}'`).join(', ')}])`],
+    [m.pricing || {}, `pricing: ${stringify(m.pricing, 2)}`],
+    [m.metrics, `metrics: ${stringify(m.metrics, 2)}`],
+    [m.metadata, `metadata: ${stringify(m.metadata, 2)}`],
+  ];
+
+  const fieldStrings = fields
+    .filter(([value]) => value !== undefined)
+    .map(([, str]) => `  ${str}`);
+
+  return `{\n${fieldStrings.join(',\n')}\n}`;
+};
 
 /**
  * Convert ModelInfo array to TypeScript source code
  */
 export function generateModelTS(models: ModelInfo[], exportName: string): string {
-  const stringify = (x: any, space?: number | string | undefined) => 
-    (JSON.stringify(x, null, space) || '')
-      .replace(/"([^"]+)":/g, '$1:')
-      .replace(/\n/g, '\n  ')
-      .trim() || undefined;
-
-  const serialized = models.map(m => {
-    const fields: [any, string][] = [
-      [m.id, `id: '${m.id}'`],
-      [m.provider, `provider: '${m.provider}'`],
-      [m.name, `name: '${m.name}'`],
-      [m.contextWindow, `contextWindow: ${m.contextWindow}`],
-      [m.maxOutputTokens, `maxOutputTokens: ${m.maxOutputTokens}`],
-      [m.tier, `tier: '${m.tier}'`],
-      [m.tokenizer, `tokenizer: '${m.tokenizer}'`],
-      [m.capabilities, `capabilities: new Set([${Array.from(m.capabilities).map(c => `'${c}'`).join(', ')}])`],
-      [m.supportedParameters?.size, `supportedParameters: new Set([${Array.from(m.supportedParameters || []).map(p => `'${p}'`).join(', ')}])`],
-      [m.pricing, `pricing: ${stringify(m.pricing, 2)}`],
-      [m.metrics, `metrics: ${stringify(m.metrics, 2)}`],
-      [m.metadata, `metadata: ${stringify(m.metadata, 2)}`],
-    ];
-
-    const fieldStrings = fields
-      .filter(([value]) => value !== undefined)
-      .map(([, str]) => `  ${str}`);
-
-    return `{\n${fieldStrings.join(',\n')}\n}`;
-  }).join(', ');
+  const serialized = models.map(stringifyModel).join(', ');
 
   return `/**
  * Generated model data

package/scripts/patch-modelinfo.ts

@@ -0,0 +1,139 @@
+import { ModelPricing } from '@aeye/ai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface ModelInfo {
+  capabilities: string[];
+  tier: string;
+  pricing: any;
+  contextWindow: number | null;
+  maxOutputTokens: number | null;
+  metrics: {
+    tokensPerSecond: number | null;
+    timeToFirstToken: number | null;
+    averageRequestDuration: number | null;
+    accuracyScore: number | null;
+  };
+  tokenizer: string;
+  supportedParameters: string[];
+}
+
+interface ResponseData {
+  transformerImplementation: string;
+  modelInfo: ModelInfo;
+}
+
+// Clean pricing object by removing null/undefined values and empty sub-objects
+function cleanPricing(pricing: any): any {
+  if (!pricing || typeof pricing !== 'object') return pricing;
+
+  const cleaned: any = {};
+
+  for (const [key, value] of Object.entries(pricing)) {
+    if (value === null || value === undefined || value === 0) { // replicate doesn't have free models
+      continue; // Skip null/undefined values
+    }
+
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      const cleanedSubObj = cleanPricing(value);
+      // Only include if the cleaned sub-object has properties
+      if (Object.keys(cleanedSubObj).length > 0) {
+        cleaned[key] = cleanedSubObj;
+      }
+    } else if (Array.isArray(value)) {
+      // Keep arrays even if empty (they might be intentionally empty)
+      cleaned[key] = value;
+    } else {
+      cleaned[key] = value;
+    }
+  }
+
+  return cleaned;
+}
+
+// Extract model name from transformer implementation
+function extractModelName(transformerImpl: string): string | null {
+  // Look for patterns like "owner/model" in the implementation
+  const match = transformerImpl.match(/"([^"]+\/[^"]+)":/);
+  return match ? match[1] : null;
+}
+
+async function processResponseFiles() {
+  const cacheDir = path.join(__dirname, '..', 'cache', 'replicate');
+  const dataFile = path.join(__dirname, '..', 'data', 'replicate-modelinfo.json');
+
+  // Get all response.txt files
+  const files = fs.readdirSync(cacheDir)
+    .filter(f => f.endsWith('-response.txt'))
+    .sort();
+
+  console.log(`Found ${files.length} response files to process`);
+
+  // Load the huge JSON file
+  const dataContent = fs.readFileSync(dataFile, 'utf-8');
+  let data: { id: string, pricing?: ModelPricing, [key: string]: unknown }[] = JSON.parse(dataContent);
+
+  let updatedCount = 0;
+  let skippedCount = 0;
+
+  for (const file of files) {
+    const filePath = path.join(cacheDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+
+    try {
+      const responseData: ResponseData = JSON.parse(content);
+      const modelName = extractModelName(responseData.transformerImplementation);
+
+      if (!modelName) {
+        console.log(`Skipping ${file}: Could not extract model name`);
+        skippedCount++;
+        continue;
+      }
+
+      // Check if model exists in the data
+      const existingModelIndex = data.findIndex(m => m.id === modelName);
+      if (existingModelIndex < 0) {
+        console.log(`Skipping ${file}: Model "${modelName}" not found in data file`);
+        skippedCount++;
+        continue;
+      }
+
+      const existingModel = data[existingModelIndex];
+
+      // Clean the pricing object
+      const tokenizer = responseData.modelInfo.tokenizer || existingModel.tokenizer || '';
+      const cleanedModelInfo = {
+        ...existingModel,
+        ...responseData.modelInfo,
+        tokenizer: !tokenizer || tokenizer === 'null' ? undefined : tokenizer,
+        contextWindow: responseData.modelInfo.contextWindow || existingModel.contextWindow || 0,
+        maxOutputTokens: responseData.modelInfo.maxOutputTokens || existingModel.maxOutputTokens || undefined,
+        pricing: cleanPricing(responseData.modelInfo.pricing || existingModel.pricing || {}),
+        metrics: cleanPricing(responseData.modelInfo.metrics || existingModel.metrics || {}),
+      };
+
+      // Update the model info
+      data[existingModelIndex] = cleanedModelInfo;
+      updatedCount++;
+      console.log(`Updated: ${modelName}`);
+
+    } catch (error) {
+      console.error(`Error processing ${file}:`, error);
+      skippedCount++;
+    }
+  }
+
+  // Write the updated data back
+  fs.writeFileSync(dataFile, JSON.stringify(data, null, 2), 'utf-8');
+
+  console.log('\n=== Summary ===');
+  console.log(`Total files processed: ${files.length}`);
+  console.log(`Successfully updated: ${updatedCount}`);
+  console.log(`Skipped: ${skippedCount}`);
+}
+
+processResponseFiles().catch(console.error);

package/scripts/scrapers/extract.md

@@ -1,59 +1,57 @@
-Run `npm run scrape:replicate`
+import z from 'zod'; // zod 4
 
-I want you to consume one model chunk file at a time. They are in cache/replicate-schemas-chunk-#.json. Each model has latest_version and in the components of the schema has Input & Output. You need to do one at a time because each file is ~ 20k tokens.
-
-What you need to do is replace/create a src/replicate.ts file with all model handlers that make sense for each model. A model handler allows you to link a particular model ID with a set of supported functions. Like chat prediction, image generation, etc.
-
-Here's the shape of the ModelHandler from the `@aeye/ai` package:
-
-```ts
-export interface ModelTransformer {
+interface ReplicateTransformer {
   chat?: {
-    convertRequest?: (request: Request, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<Response>;
-    parseChunk?: (chunk: object, ctx: AIContextAny) => Promise<Chunk>;
+    convertRequest?: (request: Request, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: object, ctx: AIContextAny) => Promise<ModelTransformerResponse<Response>>;
+    parseChunk?: (chunk: any, ctx: AIContextAny) => Promise<Chunk>;
   };
 
   imageGenerate?: {
-    convertRequest?: (request: ImageGenerationRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<ImageGenerationResponse>;
-    parseChunk?: (chunk: object, ctx: AIContextAny) => Promise<ImageGenerationChunk>;
+    convertRequest?: (request: ImageGenerationRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<ImageGenerationResponse>>;
+    parseChunk?: (chunk: any, ctx: AIContextAny) => Promise<ImageGenerationChunk>;
   };
 
   imageEdit?: {
-    convertRequest?: (request: ImageEditRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<ImageGenerationResponse>;
-    parseChunk?: (chunk: object, ctx: AIContextAny) => Promise<ImageGenerationChunk>;
+    convertRequest?: (request: ImageEditRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<ImageGenerationResponse>>;
+    parseChunk?: (chunk: any, ctx: AIContextAny) => Promise<ImageGenerationChunk>;
   };
 
   imageAnalyze?: {
-    convertRequest?: (request: ImageAnalyzeRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<Response>;
-    parseChunk?: (chunk: object, ctx: AIContextAny) => Promise<Chunk>;
+    convertRequest?: (request: ImageAnalyzeRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<Response>>;
+    parseChunk?: (chunk: any, ctx: AIContextAny) => Promise<Chunk>;
   };
 
   transcribe?: {
-    convertRequest?: (request: TranscriptionRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<TranscriptionResponse>;
-    parseChunk?: (chunk: object, ctx: AIContextAny) => Promise<TranscriptionChunk>;
+    convertRequest?: (request: TranscriptionRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<TranscriptionResponse>>;
+    parseChunk?: (chunk: any, ctx: AIContextAny) => Promise<TranscriptionChunk>;
   };
 
   speech?: {
-    convertRequest?: (request: SpeechRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<SpeechResponse>;
+    convertRequest?: (request: SpeechRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<SpeechResponse>>;
   };
 
   embed?: {
-    convertRequest?: (request: EmbeddingRequest, ctx: AIContextAny) => Promise<object>;
-    parseResponse?: (response: object, ctx: AIContextAny) => Promise<EmbeddingResponse>;
+    convertRequest?: (request: EmbeddingRequest, ctx: AIContextAny) => Promise<any>;
+    parseResponse?: (response: any, ctx: AIContextAny) => Promise<ModelTransformerResponse<EmbeddingResponse>>;
   };
 }
-```
-
-And here are the referenced types:
-```ts
-export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
-export interface Message { 
+type AIContextAny = {
+  ai: {} // special type, not important for implementation
+  metadata?: {
+    model?: ModelInput;
+    // others
+  };
+  signal?: AbortSignal;
+}
+type ModelTransformerResponse<T> = Omit<T, 'model' | 'usage'>;
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface Message { 
   role: MessageRole;
   content: string | MessageContent[];
   tokens?: number;
@@ -63,33 +61,33 @@ export interface Message {
   refusal?: string;
   cache?: Record<string, any>;
 }
-export type MessageContentType = 'text' | 'image' | 'file' | 'audio';
-export interface MessageContent {
+type MessageContentType = 'text' | 'image' | 'file' | 'audio';
+interface MessageContent {
   type: MessageContentType;
   content: Resource;
   format?: string;
 }
-export interface ToolDefinition {
+interface ToolDefinition {
   name: string;
   description?: string;
   parameters: z.ZodType<object>;
   strict?: boolean;
 }
-export interface ToolCall {
+interface ToolCall {
   id: string;
   name: string;
   arguments: string;
 }
-export type ToolChoice =
+type ToolChoice =
   | 'auto'
   | 'none'
   | 'required'
   | { tool: string };
-export type ResponseFormat =
+type ResponseFormat =
   | 'text'
   | 'json'
   | { type: z.ZodType<object, object>, strict: boolean };
-export interface Usage {
+interface Usage {
   text?: {
     input?: number;
     output?: number;
@@ -119,8 +117,8 @@ export interface Usage {
   };
   cost?: number;
 }
-export type ReasoningEffort = 'low' | 'medium' | 'high';
-export interface Request extends BaseRequest {
+type ReasoningEffort = 'low' | 'medium' | 'high';
+interface Request extends BaseRequest {
   name?: string;
   messages: Message[];
   temperature?: number;
@@ -139,33 +137,33 @@ export interface Request extends BaseRequest {
   cacheKey?: string;
   userKey?: string;
 }
-export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'refusal';
-export interface Model {
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'refusal';
+interface Model {
   id: string;
   contextWindow?: number;
   maxOutputTokens?: number;
 }
-export type ModelInput = string | Model;
-export interface BaseRequest {
+type ModelInput = string | Model;
+interface BaseRequest {
   model?: ModelInput;
   extra?: Record<string, any>;
 }
-export interface BaseResponse {
+interface BaseResponse {
   usage?: Usage;
   model: ModelInput;
 }
-export interface BaseChunk {
+interface BaseChunk {
   usage?: Usage;
   model?: ModelInput;
 }
-export interface Response extends BaseResponse {
+interface Response extends BaseResponse {
   content: string;
   toolCalls?: ToolCall[];
   finishReason: FinishReason;
   refusal?: string;
   reasoning?: string;
 }
-export interface Chunk extends BaseChunk {
+interface Chunk extends BaseChunk {
   content?: string;
   toolCallNamed?: ToolCall;
   toolCallArguments?: ToolCall;
@@ -174,7 +172,7 @@ export interface Chunk extends BaseChunk {
   refusal?: string;
   reasoning?: string;
 }
-export interface ImageGenerationRequest extends BaseRequest {
+interface ImageGenerationRequest extends BaseRequest {
   prompt: string;
   n?: number;
   size?: string;
@@ -186,7 +184,7 @@ export interface ImageGenerationRequest extends BaseRequest {
   seed?: number;
   userIdentifier?: string;
 }
-export interface ImageEditRequest extends BaseRequest {
+interface ImageEditRequest extends BaseRequest {
   prompt: string;
   image: Resource;
   mask?: Resource;
@@ -197,14 +195,14 @@ export interface ImageEditRequest extends BaseRequest {
   streamCount?: number;
   userIdentifier?: string;
 }
-export interface ImageGenerationResponse extends BaseResponse {
+interface ImageGenerationResponse extends BaseResponse {
   images: Array<{
     url?: string;
     b64_json?: string;
     revisedPrompt?: string;
   }>;
 }
-export interface ImageGenerationChunk extends BaseChunk {
+interface ImageGenerationChunk extends BaseChunk {
   imageData?: string;
   progress?: number;
   done?: boolean;
@@ -213,7 +211,7 @@ export interface ImageGenerationChunk extends BaseChunk {
     b64_json?: string;
   };
 }
-export interface TranscriptionRequest extends BaseRequest {
+interface TranscriptionRequest extends BaseRequest {
   audio: Resource;
   language?: string;
   prompt?: string;
@@ -221,45 +219,45 @@ export interface TranscriptionRequest extends BaseRequest {
   responseFormat?: 'json' | 'text' | 'srt' | 'vtt' | 'verbose_json';
   timestampGranularities?: Array<'word' | 'segment'>;
 }
-export interface TranscriptionResponse extends BaseResponse {
+interface TranscriptionResponse extends BaseResponse {
   text: string;
 }
-export interface TranscriptionChunk extends BaseChunk {
+interface TranscriptionChunk extends BaseChunk {
   delta?: string;
   text?: string;
   segment?: { start: number; end: number; speaker: string, text: string, id: string };
   status?: string;
 }
-export interface SpeechRequest extends BaseRequest{
+interface SpeechRequest extends BaseRequest{
   text: string;
   instructions?: string;
   voice?: string;
   speed?: number;
   responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
 }
-export interface SpeechResponse extends BaseResponse {
+interface SpeechResponse extends BaseResponse {
   audio: ReadableStream<any>;
   responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
 }
-export interface EmbeddingRequest extends BaseRequest {
+interface EmbeddingRequest extends BaseRequest {
   texts: string[];
   dimensions?: number;
   encodingFormat?: 'float' | 'base64';
   userIdentifier?: string;
 }
-export interface EmbeddingResponse extends BaseResponse {
+interface EmbeddingResponse extends BaseResponse {
   embeddings: Array<{
     embedding: number[];
     index: number;
   }>;
 }
-export interface ImageAnalyzeRequest extends BaseRequest{
+interface ImageAnalyzeRequest extends BaseRequest{
   prompt: string;
   images: string[];
   maxTokens?: number;
   temperature?: number;
 }
-export type Resource = 
+type Resource = 
  | string // plain text, or data URL, or http(s) URL, or file:// URL
  | AsyncIterable<Uint8Array> // fs.ReadStream, ReadableStream
  | Blob // File
@@ -270,5 +268,4 @@ export type Resource =
  | Buffer
  | { blob(): Promise<Blob> | Blob }
  | { url(): string }
- | { read(): Promise<ReadableStream> | ReadableStream }
-```
+ | { read(): Promise<ReadableStream> | ReadableStream }