@prysm-ai/llm 0.3.0

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import type { MessageContent } from './content';
+export declare const ChatMessageRoleSchema: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+export type ChatMessageRole = z.infer<typeof ChatMessageRoleSchema>;
+export interface ChatMessage {
+    id: string;
+    role: ChatMessageRole;
+    content: MessageContent;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+    metadata?: Record<string, unknown>;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface LLMResponse {
+    id: string;
+    model: string;
+    role: 'assistant';
+    content: string;
+    toolCalls?: ToolCall[];
+    finishReason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | 'function_call';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface EmbedResponse {
+    embeddings: number[][];
+    model: string;
+    usage?: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+export interface LLMRequestOptions {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    tools?: unknown[];
+    toolChoice?: unknown;
+    responseFormat?: {
+        type: 'text' | 'json_object';
+    };
+    stop?: string[];
+    stream?: boolean;
+}
+export interface EmbedRequest {
+    model: string;
+    input: string | string[];
+}
+export type LLMProvider = 'openai' | 'anthropic' | 'local';
+export interface ModelInfo {
+    provider: LLMProvider;
+    model: string;
+    displayName: string;
+    contextWindow: number;
+    supportsTools: boolean;
+    supportsVision: boolean;
+    maxOutputTokens?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,eAAO,MAAM,qBAAqB,oDAAkD,CAAC;AACrF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,gBAAgB,GAAG,YAAY,GAAG,eAAe,CAAC;IACpF,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE;QACN,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAAA;KAAE,CAAC;IAClD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/types.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export const ChatMessageRoleSchema = z.enum(['system', 'user', 'assistant', 'tool']);
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@prysm-ai/llm",
+  "version": "0.3.0",
+  "description": "LLM abstraction layer for prysm-ai",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prysm-ai/llm.git"
+  },
+  "keywords": [
+    "prysm-ai",
+    "llm",
+    "ai",
+    "agent"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "openai": "^4.0.0",
+    "zod": "^3.23.0",
+    "@prysm-ai/core": "0.3.0",
+    "@prysm-ai/utils": "0.3.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^2.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:prod": "tsc --sourceMap false --declarationMap false",
+    "build:watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "pub": "pnpm build:prod && npm publish --access public"
+  }
+}

package/src/base.ts

@@ -0,0 +1,43 @@
+import type { ChatMessage, LLMResponse, LLMRequestOptions, ModelInfo, EmbedRequest, EmbedResponse, LLMProvider } from './types';
+import type { StreamingOptions } from './provider/openai';
+
+export abstract class BaseLLMProvider {
+  abstract readonly provider: LLMProvider;
+  abstract readonly defaultModel: string;
+
+  protected apiKey!: string | undefined;
+  protected baseUrl!: string | undefined;
+
+  constructor(apiKey?: string, baseUrl?: string) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+
+  abstract chat(messages: ChatMessage[], options?: LLMRequestOptions): Promise<LLMResponse>;
+
+  abstract chatStream(messages: ChatMessage[], options: StreamingOptions): Promise<void>;
+
+  abstract listModels(): Promise<ModelInfo[]>;
+
+  abstract validateKey(): Promise<boolean>;
+
+  async embed(_request: EmbedRequest): Promise<EmbedResponse> {
+    throw new Error('Embed not supported by this provider');
+  }
+
+  getProvider(): LLMProvider {
+    return this.provider;
+  }
+
+  protected applyRequestOptions(requestBody: Record<string, unknown>, options: LLMRequestOptions): void {
+    if (options.temperature !== undefined) {
+      requestBody.temperature = options.temperature;
+    }
+    if (options.maxTokens !== undefined) {
+      requestBody.max_tokens = options.maxTokens;
+    }
+    if (options.stop !== undefined) {
+      requestBody.stop = options.stop;
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,13 @@
+export const MessageRole = {
+  System: 'system',
+  User: 'user',
+  Assistant: 'assistant',
+  Tool: 'tool',
+} as const;
+
+export type MessageRole = (typeof MessageRole)[keyof typeof MessageRole];
+
+export enum LLMProviderType {
+  OpenAI = 'openai',
+  Anthropic = 'anthropic',
+}

package/src/content.ts

@@ -0,0 +1,36 @@
+// Message content types for multimodal support
+
+export type MessageContent = string | MessagePart[];
+
+export interface TextPart {
+  type: 'text';
+  text: string;
+}
+
+export interface ImagePart {
+  type: 'image_url';
+  image_url: {
+    url: string;
+    detail?: 'low' | 'high' | 'auto';
+  };
+}
+
+export type MessagePart = TextPart | ImagePart;
+
+export function isTextPart(part: MessagePart): part is TextPart {
+  return part.type === 'text';
+}
+
+export function isImagePart(part: MessagePart): part is ImagePart {
+  return part.type === 'image_url';
+}
+
+export function hasImages(content: MessageContent): boolean {
+  if (typeof content === 'string') return false;
+  return content.some(part => part.type === 'image_url');
+}
+
+export function getTextContent(content: MessageContent): string {
+  if (typeof content === 'string') return content;
+  return content.filter(isTextPart).map(p => p.text).join('\n');
+}

package/src/factory/createModel.ts

@@ -0,0 +1,64 @@
+import { OpenAIProvider, OpenAIProviderConfig } from '../provider/openai';
+import { AnthropicProvider, AnthropicProviderConfig } from '../provider/anthropic';
+import { BaseLLMProvider } from '../base';
+
+/**
+ * createModel 配置选项
+ */
+export interface CreateModelOptions {
+  /** 接口类型: openai | anthropic */
+  type: 'openai' | 'anthropic';
+  /** 模型接口地址 */
+  baseUrl: string;
+  /** API 密钥 */
+  apiKey: string;
+  /** 模型名称 */
+  model: string;
+  /** 可选: API 路径 */
+  apiPath?: string;
+  /** 可选: 超时时间（毫秒） */
+  timeoutMs?: number;
+  /** 可选: 默认 temperature */
+  temperature?: number;
+  /** 可选: 默认 maxTokens */
+  maxTokens?: number;
+}
+
+/**
+ * 创建模型实例工厂函数
+ * 根据 type 创建对应的 Provider 实例，返回可直接使用的模型
+ *
+ * @example
+ * const model = createModel({
+ *   type: 'openai',
+ *   baseUrl: 'https://api.moonshot.cn/v1',
+ *   apiKey: process.env.MOONSHOT_API_KEY,
+ *   model: 'kimi-k2.6',
+ * });
+ *
+ * const response = await model.chat(messages);
+ */
+export function createModel(options: CreateModelOptions): BaseLLMProvider {
+  const { type, baseUrl, apiKey, apiPath, timeoutMs } = options;
+
+  switch (type) {
+    case 'openai': {
+      const config: OpenAIProviderConfig = { apiKey };
+      if (baseUrl) config.baseUrl = baseUrl;
+      if (apiPath) config.apiPath = apiPath;
+      if (timeoutMs) config.timeoutMs = timeoutMs;
+      return new OpenAIProvider(config);
+    }
+
+    case 'anthropic': {
+      const config: AnthropicProviderConfig = { apiKey };
+      if (baseUrl) config.baseUrl = baseUrl;
+      if (apiPath) config.apiPath = apiPath;
+      if (timeoutMs) config.timeoutMs = timeoutMs;
+      return new AnthropicProvider(config);
+    }
+
+    default:
+      throw new Error(`Unsupported provider type: ${type}`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './base';
+export * from './provider/openai';
+export * from './provider/anthropic';
+export * from './provider/proxy';
+export * from './router';
+export * from './content';
+export * from './constants';
+export * from './factory/createModel';

package/src/provider/anthropic.ts

@@ -0,0 +1,359 @@
+import type { ChatMessage, LLMResponse, LLMRequestOptions, ModelInfo } from '../types';
+import type { MessageContent, MessagePart } from '../content';
+import { BaseLLMProvider } from '../base';
+import { isTextPart } from '../content';
+import { MessageRole } from '../constants';
+
+export interface AnthropicStreamingOptions extends Omit<LLMRequestOptions, 'stream'> {
+  stream: true;
+  onChunk?: (chunk: string) => void;
+  onComplete?: (fullContent: string) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface AnthropicProviderConfig {
+  apiKey: string;
+  baseUrl?: string;
+  apiPath?: string;
+  timeoutMs?: number;
+}
+
+interface AnthropicImageBlock {
+  type: 'image';
+  source: {
+    type: 'base64' | 'url';
+    media_type: string;
+    data: string;
+  };
+}
+
+interface AnthropicContentBlock {
+  type: 'text';
+  text: string;
+}
+
+type AnthropicContent = AnthropicContentBlock | AnthropicImageBlock;
+
+export class AnthropicProvider extends BaseLLMProvider {
+  readonly provider: 'anthropic' = 'anthropic';
+  override readonly defaultModel = 'claude-3-5-sonnet-20241022';
+
+  private authToken: string;
+  private timeoutMs: number;
+  private apiUrl: string;
+
+  constructor(config: AnthropicProviderConfig) {
+    super(config.apiKey, config.baseUrl);
+    this.authToken = config.apiKey;
+    this.timeoutMs = config.timeoutMs ?? 60000;
+    const base = config.baseUrl ?? 'https://api.anthropic.com';
+    const path = config.apiPath ?? '/v1/messages';
+    this.apiUrl = `${base}${path}`;
+  }
+
+  async chat(messages: ChatMessage[], options: LLMRequestOptions = { model: this.defaultModel }): Promise<LLMResponse> {
+    const systemMessage = messages.find(m => m.role === MessageRole.System);
+    const conversationMessages = messages.filter(m => m.role !== MessageRole.System);
+
+    const requestBody: Record<string, unknown> = {
+      model: options.model,
+      messages: conversationMessages.map(msg => ({
+        role: msg.role,
+        content: this.normalizeContent(msg.content),
+      })),
+    };
+
+    if (systemMessage) {
+      requestBody.system = this.getTextContent(systemMessage.content);
+    }
+    this.applyRequestOptions(requestBody, options);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.authToken,
+          'anthropic-version': '2023-06-01',
+          'anthropic-dangerous-direct-browser-access': 'true',
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+      }
+
+      const data = await response.json() as {
+        id: string;
+        model: string;
+        stop_reason: string | null;
+        usage: { input_tokens: number; output_tokens: number };
+        content: Array<{ type: string; text?: string; id?: string; name?: string; input?: Record<string, unknown> }>;
+      };
+
+      const responseMessage = data.content.find(c => c.type === 'text');
+      const toolCalls = data.content
+        .filter(c => c.type === 'tool_use')
+        .map(c => ({
+          id: c.id ?? '',
+          type: 'function' as const,
+          function: {
+            name: c.name ?? '',
+            arguments: JSON.stringify(c.input ?? {}),
+          },
+        }));
+
+      const result: LLMResponse = {
+        id: data.id,
+        model: data.model,
+        role: 'assistant',
+        content: responseMessage?.text ?? '',
+        finishReason: mapFinishReason(data.stop_reason),
+        usage: {
+          promptTokens: data.usage.input_tokens,
+          completionTokens: data.usage.output_tokens,
+          totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+        },
+      };
+
+      if (toolCalls.length > 0) {
+        result.toolCalls = toolCalls;
+      }
+
+      return result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+
+  async chatStream(messages: ChatMessage[], options: AnthropicStreamingOptions): Promise<void> {
+    const systemMessage = messages.find(m => m.role === MessageRole.System);
+    const conversationMessages = messages.filter(m => m.role !== MessageRole.System);
+
+    const requestBody: Record<string, unknown> = {
+      model: options.model,
+      messages: conversationMessages.map(msg => ({
+        role: msg.role,
+        content: this.normalizeContent(msg.content),
+      })),
+      stream: true,
+    };
+
+    if (systemMessage) {
+      requestBody.system = this.getTextContent(systemMessage.content);
+    }
+
+    if (options.temperature !== undefined) {
+      requestBody.temperature = options.temperature;
+    }
+
+    if (options.maxTokens !== undefined) {
+      requestBody.max_tokens = options.maxTokens;
+    } else {
+      requestBody.max_tokens = 4096;
+    }
+
+    this.applyRequestOptions(requestBody, options);
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.authToken,
+          'anthropic-version': '2023-06-01',
+          'anthropic-dangerous-direct-browser-access': 'true',
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+      }
+
+      // SSE streaming response
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error('No response body');
+      }
+
+      const decoder = new TextDecoder();
+      let fullContent = '';
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            if (data === '[DONE]') continue;
+
+            try {
+              const event = JSON.parse(data);
+              if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                const text = event.delta.text;
+                fullContent += text;
+                options.onChunk?.(text);
+              }
+            } catch {
+              // Ignore parse errors for partial lines
+            }
+          }
+        }
+      }
+
+      options.onComplete?.(fullContent);
+    } catch (error) {
+      options.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+
+  /**
+   * 将消息内容规范化为 Anthropic 格式
+   * @param content - MessageContent 类型: string | MessagePart[]
+   *   - string: 纯文本内容，直接返回
+   *   - MessagePart[]: 文本/图片部分数组，转换为 Anthropic 内容块
+   * @returns 纯文本返回 string，多模态内容返回 AnthropicContent[]
+   */
+  private normalizeContent(content: MessageContent): string | AnthropicContent[] {
+    // 步骤1: 如果内容是纯字符串，直接返回（Anthropic 接受字符串格式）
+    if (typeof content === 'string') {
+      return content;
+    }
+    // 步骤2: 如果内容是数组，规范化每个部分
+    return content.map(part => this.normalizePart(part));
+  }
+
+  /**
+   * 将单个消息部分规范化为 Anthropic 内容块
+   * @param part - MessagePart 类型: TextPart | ImagePart
+   *   - TextPart: { type: 'text', text: string }
+   *   - ImagePart: { type: 'image_url', image_url: { url: string, detail?: 'low'|'high'|'auto' } }
+   * @returns AnthropicContent: { type: 'text', text: string } | { type: 'image', source: {...} }
+   */
+  private normalizePart(part: MessagePart): AnthropicContent {
+    // 步骤1: 处理文本部分 - 转换为 Anthropic 文本块
+    if (part.type === 'text') {
+      return { type: 'text', text: part.text };
+    }
+    // 步骤2: 处理图片部分 - 转换为 Anthropic 图片块
+    if (part.type === 'image_url') {
+      const urlOrData = part.image_url.url;
+      // 步骤2a: 如果是 data URI（base64），解析并转换为 Anthropic base64 格式
+      if (urlOrData.startsWith('data:')) {
+        // 解析 data URI 格式: data:image/png;base64,<编码数据>
+        const match = urlOrData.match(/^data:(\w+\/\w+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: match[1]!, // 例如 'image/png'
+              data: match[2]!,        // base64 编码内容
+            },
+          };
+        }
+      }
+      // 步骤2b: 如果是普通 URL，转换为 Anthropic URL 格式
+      return {
+        type: 'image',
+        source: {
+          type: 'url',
+          media_type: 'image/png', // URL 默认假设为 PNG
+          data: urlOrData,
+        },
+      };
+    }
+    // 降级处理: 未知类型返回空文本块
+    return { type: 'text', text: '' };
+  }
+
+  private getTextContent(content: MessageContent): string {
+    if (typeof content === 'string') {
+      return content;
+    }
+    return content.filter(isTextPart).map(p => p.text).join('\n');
+  }
+
+  protected override applyRequestOptions(requestBody: Record<string, unknown>, options: LLMRequestOptions): void {
+    super.applyRequestOptions(requestBody, options);
+    if (options.temperature !== undefined) {
+      requestBody.temperature = options.temperature;
+    }
+
+    if (options.maxTokens !== undefined) {
+      requestBody.max_tokens = options.maxTokens;
+    } else {
+      requestBody.max_tokens = 4096;
+    }
+
+    if (options.stop !== undefined) {
+      requestBody.stop_sequences = options.stop;
+    }
+
+    if (options.tools !== undefined) {
+      requestBody.tools = options.tools;
+    }
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    return [
+      { provider: 'anthropic', model: 'claude-3-5-sonnet-20241022', displayName: 'Claude 3.5 Sonnet', contextWindow: 200000, supportsTools: true, supportsVision: true },
+      { provider: 'anthropic', model: 'claude-3-opus-20240229', displayName: 'Claude 3 Opus', contextWindow: 200000, supportsTools: true, supportsVision: true },
+      { provider: 'anthropic', model: 'claude-3-haiku-20240307', displayName: 'Claude 3 Haiku', contextWindow: 200000, supportsTools: true, supportsVision: true },
+    ];
+  }
+
+  async validateKey(): Promise<boolean> {
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.authToken,
+          'anthropic-version': '2023-06-01',
+          'anthropic-dangerous-direct-browser-access': 'true',
+        },
+        body: JSON.stringify({
+          model: this.defaultModel,
+          messages: [{ role: 'user', content: 'test' }],
+          max_tokens: 1,
+        }),
+      });
+      return response.ok || response.status === 400;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function mapFinishReason(reason: string | null): LLMResponse['finishReason'] {
+  switch (reason) {
+    case 'end_turn': return 'stop';
+    case 'max_tokens': return 'length';
+    case 'stop_sequence': return 'stop';
+    case 'tool_use': return 'tool_calls';
+    default: return 'stop';
+  }
+}