@radaros/core 0.3.5 → 0.3.6

package/src/models/providers/openai.ts

@@ -1,345 +0,0 @@
-import { createRequire } from "node:module";
-import type { ModelProvider } from "../provider.js";
-import {
-  getTextContent,
-  isMultiModal,
-  type ChatMessage,
-  type ContentPart,
-  type ModelConfig,
-  type ModelResponse,
-  type StreamChunk,
-  type ToolDefinition,
-  type TokenUsage,
-  type ToolCall,
-} from "../types.js";
-
-const _require = createRequire(import.meta.url);
-
-interface OpenAIConfig {
-  apiKey?: string;
-  baseURL?: string;
-}
-
-export class OpenAIProvider implements ModelProvider {
-  readonly providerId = "openai";
-  readonly modelId: string;
-  private client: any;
-  private OpenAICtor: any;
-  private baseURL?: string;
-  private clientCache = new Map<string, any>();
-
-  constructor(modelId: string, config?: OpenAIConfig) {
-    this.modelId = modelId;
-    this.baseURL = config?.baseURL;
-    try {
-      const mod = _require("openai");
-      this.OpenAICtor = mod.default ?? mod;
-      const key = config?.apiKey ?? process.env.OPENAI_API_KEY;
-      if (key) {
-        this.client = new this.OpenAICtor({ apiKey: key, baseURL: config?.baseURL });
-      }
-    } catch {
-      throw new Error(
-        "openai package is required for OpenAIProvider. Install it: npm install openai"
-      );
-    }
-  }
-
-  private getClient(apiKey?: string): any {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.OpenAICtor({ apiKey, baseURL: this.baseURL });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.client) return this.client;
-    const envKey = process.env.OPENAI_API_KEY;
-    if (envKey) {
-      this.client = new this.OpenAICtor({ apiKey: envKey, baseURL: this.baseURL });
-      return this.client;
-    }
-    throw new Error("No OpenAI API key provided. Pass it via the x-openai-api-key header, apiKey in request body, or set OPENAI_API_KEY env var.");
-  }
-
-  async generate(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): Promise<ModelResponse> {
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      messages: this.toOpenAIMessages(messages),
-    };
-
-    if (options?.reasoning?.enabled) {
-      params.reasoning_effort = options.reasoning.effort ?? "medium";
-    } else {
-      if (options?.temperature !== undefined)
-        params.temperature = options.temperature;
-    }
-    if (options?.maxTokens !== undefined)
-      params.max_tokens = options.maxTokens;
-    if (options?.topP !== undefined) params.top_p = options.topP;
-    if (options?.stop) params.stop = options.stop;
-    this.applyResponseFormat(params, options);
-    if (options?.tools?.length) {
-      params.tools = this.toOpenAITools(options.tools);
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const response = await client.chat.completions.create(params);
-    return this.normalizeResponse(response);
-  }
-
-  async *stream(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): AsyncGenerator<StreamChunk> {
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      messages: this.toOpenAIMessages(messages),
-      stream: true,
-    };
-
-    if (options?.reasoning?.enabled) {
-      params.reasoning_effort = options.reasoning.effort ?? "medium";
-    } else {
-      if (options?.temperature !== undefined)
-        params.temperature = options.temperature;
-    }
-    if (options?.maxTokens !== undefined)
-      params.max_tokens = options.maxTokens;
-    if (options?.topP !== undefined) params.top_p = options.topP;
-    if (options?.stop) params.stop = options.stop;
-    this.applyResponseFormat(params, options);
-    if (options?.tools?.length) {
-      params.tools = this.toOpenAITools(options.tools);
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const stream = await client.chat.completions.create(params);
-
-    const activeToolCalls = new Map<
-      number,
-      { id: string; name: string; args: string }
-    >();
-
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0];
-      if (!choice) continue;
-
-      const delta = choice.delta;
-
-      if (delta?.content) {
-        yield { type: "text", text: delta.content };
-      }
-
-      if (delta?.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index ?? 0;
-
-          if (tc.id) {
-            activeToolCalls.set(idx, {
-              id: tc.id,
-              name: tc.function?.name ?? "",
-              args: tc.function?.arguments ?? "",
-            });
-            yield {
-              type: "tool_call_start",
-              toolCall: {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-              },
-            };
-          } else if (tc.function?.arguments) {
-            const existing = activeToolCalls.get(idx);
-            if (existing) {
-              existing.args += tc.function.arguments;
-              yield {
-                type: "tool_call_delta",
-                toolCallId: existing.id,
-                argumentsDelta: tc.function.arguments,
-              };
-            }
-          }
-
-          if (tc.function?.name && !tc.id) {
-            const existing = activeToolCalls.get(idx);
-            if (existing) {
-              existing.name = tc.function.name;
-            }
-          }
-        }
-      }
-
-      if (delta?.reasoning_content) {
-        yield { type: "thinking", text: delta.reasoning_content };
-      }
-
-      if (choice.finish_reason) {
-        for (const [, tc] of activeToolCalls) {
-          yield { type: "tool_call_end", toolCallId: tc.id };
-        }
-
-        const reasoningTkns = chunk.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
-        yield {
-          type: "finish",
-          finishReason:
-            choice.finish_reason === "tool_calls"
-              ? "tool_calls"
-              : choice.finish_reason,
-          usage: chunk.usage
-            ? {
-                promptTokens: chunk.usage.prompt_tokens ?? 0,
-                completionTokens: chunk.usage.completion_tokens ?? 0,
-                totalTokens: chunk.usage.total_tokens ?? 0,
-                ...(reasoningTkns > 0 ? { reasoningTokens: reasoningTkns } : {}),
-              }
-            : undefined,
-        };
-      }
-    }
-  }
-
-  private applyResponseFormat(params: Record<string, unknown>, options?: ModelConfig): void {
-    if (!options?.responseFormat) return;
-    if (options.responseFormat === "json") {
-      params.response_format = { type: "json_object" };
-    } else if (options.responseFormat === "text") {
-      // default
-    } else if (typeof options.responseFormat === "object") {
-      params.response_format = {
-        type: "json_schema",
-        json_schema: {
-          name: options.responseFormat.name ?? "response",
-          schema: options.responseFormat.schema,
-          strict: true,
-        },
-      };
-    }
-  }
-
-  private toOpenAIMessages(messages: ChatMessage[]): unknown[] {
-    return messages.map((msg) => {
-      if (msg.role === "assistant" && msg.toolCalls?.length) {
-        return {
-          role: "assistant",
-          content: getTextContent(msg.content),
-          tool_calls: msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.arguments),
-            },
-          })),
-        };
-      }
-
-      if (msg.role === "tool") {
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: getTextContent(msg.content),
-        };
-      }
-
-      if (isMultiModal(msg.content)) {
-        return {
-          role: msg.role,
-          content: msg.content.map((part) => this.partToOpenAI(part)),
-        };
-      }
-
-      return {
-        role: msg.role,
-        content: msg.content ?? "",
-      };
-    });
-  }
-
-  private partToOpenAI(part: ContentPart): unknown {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text };
-      case "image": {
-        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
-        return {
-          type: "image_url",
-          image_url: {
-            url: isUrl ? part.data : `data:${part.mimeType ?? "image/png"};base64,${part.data}`,
-          },
-        };
-      }
-      case "audio":
-        return {
-          type: "input_audio",
-          input_audio: {
-            data: part.data,
-            format: part.mimeType?.split("/")[1] ?? "mp3",
-          },
-        };
-      case "file":
-        return {
-          type: "text",
-          text: `[File: ${part.filename ?? "attachment"} (${part.mimeType})]`,
-        };
-    }
-  }
-
-  private toOpenAITools(
-    tools: ToolDefinition[]
-  ): unknown[] {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
-    }));
-  }
-
-  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
-    const choice = response.choices[0];
-    const msg = choice.message;
-
-    const toolCalls: ToolCall[] = (msg.tool_calls ?? []).map((tc: any) => ({
-      id: tc.id,
-      name: tc.function.name,
-      arguments: JSON.parse(tc.function.arguments || "{}"),
-    }));
-
-    const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
-    const usage: TokenUsage = {
-      promptTokens: response.usage?.prompt_tokens ?? 0,
-      completionTokens: response.usage?.completion_tokens ?? 0,
-      totalTokens: response.usage?.total_tokens ?? 0,
-      ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
-    };
-
-    let finishReason: ModelResponse["finishReason"] = "stop";
-    if (choice.finish_reason === "tool_calls") finishReason = "tool_calls";
-    else if (choice.finish_reason === "length") finishReason = "length";
-    else if (choice.finish_reason === "content_filter")
-      finishReason = "content_filter";
-
-    const result: ModelResponse & { thinking?: string } = {
-      message: {
-        role: "assistant",
-        content: msg.content ?? null,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      },
-      usage,
-      finishReason,
-      raw: response,
-    };
-
-    if (msg.reasoning_content) {
-      result.thinking = msg.reasoning_content;
-    }
-
-    return result;
-  }
-}