@radaros/core 0.3.4 → 0.3.6

package/src/models/providers/google.ts

@@ -1,386 +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 GoogleConfig {
-  apiKey?: string;
-}
-
-export class GoogleProvider implements ModelProvider {
-  readonly providerId = "google";
-  readonly modelId: string;
-  private ai: any;
-  private GoogleGenAICtor: any;
-  private clientCache = new Map<string, any>();
-
-  constructor(modelId: string, config?: GoogleConfig) {
-    this.modelId = modelId;
-    try {
-      const { GoogleGenAI } = _require("@google/genai");
-      this.GoogleGenAICtor = GoogleGenAI;
-      const key = config?.apiKey ?? process.env.GOOGLE_API_KEY;
-      if (key) {
-        this.ai = new GoogleGenAI({ apiKey: key });
-      }
-    } catch {
-      throw new Error(
-        "@google/genai is required for GoogleProvider. Install it: npm install @google/genai"
-      );
-    }
-  }
-
-  private getClient(apiKey?: string): any {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.GoogleGenAICtor({ apiKey });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.ai) return this.ai;
-    const envKey = process.env.GOOGLE_API_KEY;
-    if (envKey) {
-      this.ai = new this.GoogleGenAICtor({ apiKey: envKey });
-      return this.ai;
-    }
-    throw new Error("No Google API key provided. Pass it via the x-google-api-key header, apiKey in request body, or set GOOGLE_API_KEY env var.");
-  }
-
-  async generate(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): Promise<ModelResponse> {
-    const { systemInstruction, contents } = this.toGoogleMessages(messages);
-
-    const config: Record<string, unknown> = {};
-    if (options?.temperature !== undefined)
-      config.temperature = options.temperature;
-    if (options?.maxTokens !== undefined)
-      config.maxOutputTokens = options.maxTokens;
-    if (options?.topP !== undefined) config.topP = options.topP;
-    if (options?.stop) config.stopSequences = options.stop;
-
-    if (options?.responseFormat) {
-      config.responseMimeType = "application/json";
-      const rf = options.responseFormat;
-      if (typeof rf === "object" && rf !== null && "type" in rf && rf.type === "json_schema" && "schema" in rf && rf.schema) {
-        config.responseSchema = this.cleanJsonSchema(rf.schema as Record<string, unknown>);
-      }
-    }
-
-    if (options?.reasoning?.enabled) {
-      config.thinkingConfig = {
-        thinkingBudget: options.reasoning.budgetTokens ?? 10000,
-      };
-    }
-
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      contents,
-      config,
-    };
-
-    if (systemInstruction) params.systemInstruction = systemInstruction;
-    if (options?.tools?.length) {
-      params.tools = [
-        {
-          functionDeclarations: this.toGoogleTools(options.tools),
-        },
-      ];
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const response = await client.models.generateContent(params);
-    return this.normalizeResponse(response);
-  }
-
-  async *stream(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): AsyncGenerator<StreamChunk> {
-    const { systemInstruction, contents } = this.toGoogleMessages(messages);
-
-    const config: Record<string, unknown> = {};
-    if (options?.temperature !== undefined)
-      config.temperature = options.temperature;
-    if (options?.maxTokens !== undefined)
-      config.maxOutputTokens = options.maxTokens;
-    if (options?.topP !== undefined) config.topP = options.topP;
-    if (options?.stop) config.stopSequences = options.stop;
-
-    if (options?.reasoning?.enabled) {
-      config.thinkingConfig = {
-        thinkingBudget: options.reasoning.budgetTokens ?? 10000,
-      };
-    }
-
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      contents,
-      config,
-    };
-
-    if (systemInstruction) params.systemInstruction = systemInstruction;
-    if (options?.tools?.length) {
-      params.tools = [
-        {
-          functionDeclarations: this.toGoogleTools(options.tools),
-        },
-      ];
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const streamResult =
-      await client.models.generateContentStream(params);
-
-    let toolCallCounter = 0;
-
-    for await (const chunk of streamResult) {
-      const candidate = chunk.candidates?.[0];
-      if (!candidate?.content?.parts) continue;
-
-      for (const part of candidate.content.parts) {
-        if (part.thought) {
-          yield { type: "thinking", text: part.text ?? "" };
-        } else if (part.text) {
-          yield { type: "text", text: part.text };
-        }
-
-        if (part.functionCall) {
-          const id = `google_tc_${toolCallCounter++}`;
-          yield {
-            type: "tool_call_start",
-            toolCall: { id, name: part.functionCall.name },
-          };
-          yield {
-            type: "tool_call_delta",
-            toolCallId: id,
-            argumentsDelta: JSON.stringify(part.functionCall.args ?? {}),
-          };
-          yield { type: "tool_call_end", toolCallId: id };
-        }
-      }
-
-      if (candidate.finishReason) {
-        let finishReason = "stop";
-        if (
-          candidate.finishReason === "STOP" ||
-          candidate.finishReason === "END_TURN"
-        ) {
-          finishReason = "stop";
-        } else if (candidate.finishReason === "MAX_TOKENS") {
-          finishReason = "length";
-        } else if (candidate.finishReason === "SAFETY") {
-          finishReason = "content_filter";
-        }
-
-        const hasToolCalls = candidate.content?.parts?.some(
-          (p: any) => p.functionCall
-        );
-        if (hasToolCalls) finishReason = "tool_calls";
-
-        yield {
-          type: "finish",
-          finishReason,
-          usage: chunk.usageMetadata
-            ? {
-                promptTokens: chunk.usageMetadata.promptTokenCount ?? 0,
-                completionTokens:
-                  chunk.usageMetadata.candidatesTokenCount ?? 0,
-                totalTokens: chunk.usageMetadata.totalTokenCount ?? 0,
-              }
-            : undefined,
-        };
-      }
-    }
-  }
-
-  private toGoogleMessages(messages: ChatMessage[]): {
-    systemInstruction: string | undefined;
-    contents: unknown[];
-  } {
-    let systemInstruction: string | undefined;
-    const contents: unknown[] = [];
-
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        systemInstruction = getTextContent(msg.content) || undefined;
-        continue;
-      }
-
-      if (msg.role === "user") {
-        if (isMultiModal(msg.content)) {
-          contents.push({
-            role: "user",
-            parts: msg.content.map((p) => this.partToGoogle(p)),
-          });
-        } else {
-          contents.push({
-            role: "user",
-            parts: [{ text: msg.content ?? "" }],
-          });
-        }
-        continue;
-      }
-
-      if (msg.role === "assistant") {
-        const parts: unknown[] = [];
-        if (msg.content) {
-          parts.push({ text: msg.content });
-        }
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            parts.push({
-              functionCall: { name: tc.name, args: tc.arguments },
-            });
-          }
-        }
-        if (parts.length === 0) {
-          parts.push({ text: "" });
-        }
-        contents.push({ role: "model", parts });
-        continue;
-      }
-
-      if (msg.role === "tool") {
-        contents.push({
-          role: "function",
-          parts: [
-            {
-              functionResponse: {
-                name: msg.name ?? "unknown",
-                response: { result: msg.content ?? "" },
-              },
-            },
-          ],
-        });
-        continue;
-      }
-    }
-
-    return { systemInstruction, contents };
-  }
-
-  private partToGoogle(part: ContentPart): unknown {
-    switch (part.type) {
-      case "text":
-        return { text: part.text };
-      case "image":
-      case "audio":
-      case "file": {
-        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
-        if (isUrl) {
-          return { fileData: { fileUri: part.data, mimeType: part.mimeType ?? (part.type === "image" ? "image/png" : "application/octet-stream") } };
-        }
-        return {
-          inlineData: {
-            data: part.data,
-            mimeType: part.mimeType ?? (part.type === "image" ? "image/png" : part.type === "audio" ? "audio/mp3" : "application/octet-stream"),
-          },
-        };
-      }
-    }
-  }
-
-  private toGoogleTools(
-    tools: ToolDefinition[]
-  ): unknown[] {
-    return tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters,
-    }));
-  }
-
-  private cleanJsonSchema(schema: Record<string, unknown>): Record<string, unknown> {
-    const cleaned = { ...schema };
-    delete cleaned["$schema"];
-    delete cleaned["$ref"];
-    delete cleaned["additionalProperties"];
-
-    if (cleaned.properties && typeof cleaned.properties === "object") {
-      const props: Record<string, unknown> = {};
-      for (const [key, val] of Object.entries(cleaned.properties as Record<string, unknown>)) {
-        props[key] = typeof val === "object" && val ? this.cleanJsonSchema(val as Record<string, unknown>) : val;
-      }
-      cleaned.properties = props;
-    }
-
-    if (cleaned.items && typeof cleaned.items === "object") {
-      cleaned.items = this.cleanJsonSchema(cleaned.items as Record<string, unknown>);
-    }
-
-    return cleaned;
-  }
-
-  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
-    const candidate = response.candidates?.[0];
-    const parts = candidate?.content?.parts ?? [];
-
-    let textContent = "";
-    let thinkingContent = "";
-    const toolCalls: ToolCall[] = [];
-    let toolCallCounter = 0;
-
-    for (const part of parts) {
-      if (part.thought && part.text) {
-        thinkingContent += part.text;
-      } else if (part.text) {
-        textContent += part.text;
-      }
-      if (part.functionCall) {
-        toolCalls.push({
-          id: `google_tc_${toolCallCounter++}`,
-          name: part.functionCall.name,
-          arguments: part.functionCall.args ?? {},
-        });
-      }
-    }
-
-    const thinkingTokens = response.usageMetadata?.thoughtsTokenCount ?? 0;
-    const usage: TokenUsage = {
-      promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
-      completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
-      totalTokens: response.usageMetadata?.totalTokenCount ?? 0,
-      ...(thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {}),
-    };
-
-    let finishReason: ModelResponse["finishReason"] = "stop";
-    if (toolCalls.length > 0) finishReason = "tool_calls";
-    else if (candidate?.finishReason === "MAX_TOKENS")
-      finishReason = "length";
-    else if (candidate?.finishReason === "SAFETY")
-      finishReason = "content_filter";
-
-    const result: ModelResponse & { thinking?: string } = {
-      message: {
-        role: "assistant",
-        content: textContent || null,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      },
-      usage,
-      finishReason,
-      raw: response,
-    };
-
-    if (thinkingContent) {
-      result.thinking = thinkingContent;
-    }
-
-    return result;
-  }
-}

package/src/models/providers/ollama.ts

@@ -1,211 +0,0 @@
-import { createRequire } from "node:module";
-import type { ModelProvider } from "../provider.js";
-import type {
-  ChatMessage,
-  ModelConfig,
-  ModelResponse,
-  StreamChunk,
-  ToolDefinition,
-  TokenUsage,
-  ToolCall,
-} from "../types.js";
-
-const _require = createRequire(import.meta.url);
-
-interface OllamaConfig {
-  host?: string;
-}
-
-export class OllamaProvider implements ModelProvider {
-  readonly providerId = "ollama";
-  readonly modelId: string;
-  private client: any;
-
-  constructor(modelId: string, config?: OllamaConfig) {
-    this.modelId = modelId;
-    try {
-      const { Ollama } = _require("ollama");
-      this.client = new Ollama({
-        host: config?.host ?? "http://localhost:11434",
-      });
-    } catch {
-      throw new Error(
-        "ollama package is required for OllamaProvider. Install it: npm install ollama"
-      );
-    }
-  }
-
-  async generate(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): Promise<ModelResponse> {
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      messages: this.toOllamaMessages(messages),
-      stream: false,
-    };
-
-    const ollamaOptions: Record<string, unknown> = {};
-    if (options?.temperature !== undefined)
-      ollamaOptions.temperature = options.temperature;
-    if (options?.topP !== undefined) ollamaOptions.top_p = options.topP;
-    if (options?.stop) ollamaOptions.stop = options.stop;
-    if (options?.maxTokens !== undefined)
-      ollamaOptions.num_predict = options.maxTokens;
-
-    if (Object.keys(ollamaOptions).length > 0) params.options = ollamaOptions;
-
-    if (options?.tools?.length) {
-      params.tools = this.toOllamaTools(options.tools);
-    }
-
-    if (options?.responseFormat === "json") {
-      params.format = "json";
-    }
-
-    const response = await this.client.chat(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.toOllamaMessages(messages),
-      stream: true,
-    };
-
-    const ollamaOptions: Record<string, unknown> = {};
-    if (options?.temperature !== undefined)
-      ollamaOptions.temperature = options.temperature;
-    if (options?.topP !== undefined) ollamaOptions.top_p = options.topP;
-    if (options?.stop) ollamaOptions.stop = options.stop;
-    if (options?.maxTokens !== undefined)
-      ollamaOptions.num_predict = options.maxTokens;
-
-    if (Object.keys(ollamaOptions).length > 0) params.options = ollamaOptions;
-
-    if (options?.tools?.length) {
-      params.tools = this.toOllamaTools(options.tools);
-    }
-
-    if (options?.responseFormat === "json") {
-      params.format = "json";
-    }
-
-    const stream = await this.client.chat(params);
-
-    let toolCallCounter = 0;
-
-    for await (const chunk of stream) {
-      if (chunk.message?.content) {
-        yield { type: "text", text: chunk.message.content };
-      }
-
-      if (chunk.message?.tool_calls) {
-        for (const tc of chunk.message.tool_calls) {
-          const id = `ollama_tc_${toolCallCounter++}`;
-          yield {
-            type: "tool_call_start",
-            toolCall: {
-              id,
-              name: tc.function?.name ?? "",
-            },
-          };
-          yield {
-            type: "tool_call_delta",
-            toolCallId: id,
-            argumentsDelta: JSON.stringify(tc.function?.arguments ?? {}),
-          };
-          yield { type: "tool_call_end", toolCallId: id };
-        }
-      }
-
-      if (chunk.done) {
-        const hasToolCalls = chunk.message?.tool_calls?.length > 0;
-        yield {
-          type: "finish",
-          finishReason: hasToolCalls ? "tool_calls" : "stop",
-          usage: {
-            promptTokens: chunk.prompt_eval_count ?? 0,
-            completionTokens: chunk.eval_count ?? 0,
-            totalTokens:
-              (chunk.prompt_eval_count ?? 0) + (chunk.eval_count ?? 0),
-          },
-        };
-      }
-    }
-  }
-
-  private toOllamaMessages(messages: ChatMessage[]): unknown[] {
-    return messages.map((msg) => {
-      if (msg.role === "assistant" && msg.toolCalls?.length) {
-        return {
-          role: "assistant",
-          content: msg.content ?? "",
-          tool_calls: msg.toolCalls.map((tc) => ({
-            function: {
-              name: tc.name,
-              arguments: tc.arguments,
-            },
-          })),
-        };
-      }
-
-      if (msg.role === "tool") {
-        return {
-          role: "tool",
-          content: msg.content ?? "",
-        };
-      }
-
-      return {
-        role: msg.role,
-        content: msg.content ?? "",
-      };
-    });
-  }
-
-  private toOllamaTools(tools: ToolDefinition[]): unknown[] {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
-    }));
-  }
-
-  private normalizeResponse(response: any): ModelResponse {
-    const toolCalls: ToolCall[] = (response.message?.tool_calls ?? []).map(
-      (tc: any, i: number) => ({
-        id: `ollama_tc_${i}`,
-        name: tc.function?.name ?? "",
-        arguments: tc.function?.arguments ?? {},
-      })
-    );
-
-    const usage: TokenUsage = {
-      promptTokens: response.prompt_eval_count ?? 0,
-      completionTokens: response.eval_count ?? 0,
-      totalTokens:
-        (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
-    };
-
-    const hasToolCalls = toolCalls.length > 0;
-
-    return {
-      message: {
-        role: "assistant",
-        content: response.message?.content ?? null,
-        toolCalls: hasToolCalls ? toolCalls : undefined,
-      },
-      usage,
-      finishReason: hasToolCalls ? "tool_calls" : "stop",
-      raw: response,
-    };
-  }
-}