veryfront 0.1.372 → 0.1.374

package/src/src/provider/runtime-loader.ts

@@ -1,27 +1,11 @@
-import type { EmbeddingRuntime, ModelRuntime } from "./types.js";
-import {
-  getAnthropicMessagesUrl,
-  getGoogleEmbeddingUrl,
-  getGoogleGenerateContentUrl,
-  getGoogleStreamGenerateContentUrl,
-} from "./runtime-loader/provider-endpoints.js";
-import {
-  extractGoogleEmbedding,
-  extractGoogleUsageTokens,
-  isNumberArray,
-} from "./runtime-loader/provider-embedding-responses.js";
-import {
-  normalizeAnthropicFinishReason,
-  normalizeGoogleFinishReason,
-} from "./runtime-loader/provider-finish-reasons.js";
-import {
-  createAnthropicRequestInit,
-  createGoogleRequestInit,
-} from "./runtime-loader/provider-request-init.js";
+import type { ModelRuntime } from "./types.js";
+import { getAnthropicMessagesUrl } from "./runtime-loader/provider-endpoints.js";
+import { isNumberArray } from "./runtime-loader/provider-embedding-responses.js";
+import { normalizeAnthropicFinishReason } from "./runtime-loader/provider-finish-reasons.js";
+import { createAnthropicRequestInit } from "./runtime-loader/provider-request-init.js";
 import { parseSseChunk } from "./runtime-loader/provider-sse.js";
 import {
   extractAnthropicUsage,
-  extractGoogleUsage,
   mergeUsage,
   type RuntimeUsage,
 } from "./runtime-loader/provider-usage.js";
@@ -51,10 +35,12 @@ export {
   isNumberArray,
   mergeUsage,
   parseRetryAfterMs,
+  parseSseChunk,
   readRecord,
   requestJson,
   requestStream,
 };
+export type { RuntimeUsage };
 
 export interface AnthropicRuntimeConfig {
   apiKey?: string;
@@ -64,13 +50,6 @@ export interface AnthropicRuntimeConfig {
   fetch?: typeof globalThis.fetch;
 }
 
-export interface GoogleRuntimeConfig {
-  apiKey: string;
-  baseURL?: string;
-  name?: string;
-  fetch?: typeof globalThis.fetch;
-}
-
 export type RuntimePromptMessage =
   | { role: "system"; content: string }
   | { role: "user"; content: Array<{ type: "text"; text: string }> }
@@ -282,29 +261,6 @@ type OpenAICompatibleLanguageOptions = {
    * specify for the target feature.
    */
   anthropicContainer?: unknown;
-  /**
-   * Google-specific. Reference to a previously-created Gemini cached
-   * content resource (created via the separate caches API) to attach
-   * to this request. Resource name format:
-   * `cachedContents/<id>`. See https://ai.google.dev/gemini-api/docs/caching.
-   *
-   * Cache creation itself is out of scope for the runtime — callers
-   * use the Gemini REST API or SDK to create the cache, then pass the
-   * resource name here on each subsequent generate call to attach the
-   * cached prefix and avoid re-paying for it.
-   */
-  googleCachedContent?: string;
-  /**
-   * Google-specific. Per-request safety filter configuration for
-   * Gemini. Each entry pairs a HARM_CATEGORY_* with a threshold
-   * (BLOCK_NONE / BLOCK_LOW_AND_ABOVE / BLOCK_MEDIUM_AND_ABOVE /
-   * BLOCK_ONLY_HIGH). Forwarded verbatim as the `safetySettings`
-   * field. See https://ai.google.dev/gemini-api/docs/safety-settings.
-   */
-  googleSafetySettings?: Array<{
-    category: string;
-    threshold: string;
-  }>;
   /**
    * Anthropic-specific. Native MCP server definitions to pass directly
    * on the Messages API request body. Lets callers register MCP servers
@@ -398,23 +354,6 @@ type AnthropicStreamToolCallState = {
 type AnthropicStreamReasoningState = {
   id: string;
 };
-type GoogleCompatibleContent = {
-  role: "user" | "model";
-  parts: Array<Record<string, unknown>>;
-};
-type GoogleCompatibleRequest = {
-  contents: GoogleCompatibleContent[];
-  systemInstruction?: {
-    parts: Array<{ text: string }>;
-  };
-  tools?: Array<Record<string, unknown>>;
-  toolConfig?: {
-    functionCallingConfig: Record<string, unknown>;
-  };
-  generationConfig?: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
 /**
  * Structured warning emitted when a provider runtime drops or rewrites a
  * caller-provided option. Mirrors the AI ecosystem convention (Vercel AI
@@ -1454,120 +1393,7 @@ async function* streamAnthropicCompatibleParts(
   };
 }
 
-function toGoogleContents(
-  prompt: RuntimePromptMessage[],
-): {
-  systemInstruction?: { parts: Array<{ text: string }> };
-  contents: GoogleCompatibleContent[];
-} {
-  const systemParts: string[] = [];
-  const contents: GoogleCompatibleContent[] = [];
-
-  for (const message of prompt) {
-    switch (message.role) {
-      case "system":
-        if (message.content.length > 0) {
-          systemParts.push(message.content);
-        }
-        break;
-      case "user":
-        contents.push({
-          role: "user",
-          parts: [{ text: readTextParts(message.content) }],
-        });
-        break;
-      case "assistant": {
-        // Anthropic-only `reasoning` parts have no Gemini equivalent
-        // and are dropped on replay.
-        const parts: Array<Record<string, unknown>> = [];
-        for (const part of message.content) {
-          if (part.type === "text") {
-            parts.push({ text: part.text });
-            continue;
-          }
-          if (part.type === "reasoning") {
-            continue;
-          }
-          parts.push({
-            functionCall: {
-              id: part.toolCallId,
-              name: part.toolName,
-              args: part.input,
-            },
-          });
-        }
-        contents.push({ role: "model", parts });
-        break;
-      }
-      case "tool":
-        contents.push({
-          role: "user",
-          parts: message.content.map((part) => ({
-            functionResponse: {
-              id: part.toolCallId,
-              name: part.toolName,
-              response: {
-                result: part.output.value,
-              },
-            },
-          })),
-        });
-        break;
-    }
-  }
-
-  return {
-    ...(systemParts.length > 0
-      ? { systemInstruction: { parts: systemParts.map((text) => ({ text })) } }
-      : {}),
-    contents,
-  };
-}
-
-function toGoogleTools(
-  tools: RuntimeToolDefinition[] | undefined,
-): Array<Record<string, unknown>> | undefined {
-  if (!tools) {
-    return undefined;
-  }
-
-  const functionDeclarations: Array<Record<string, unknown>> = [];
-  const providerEntries: Array<Record<string, unknown>> = [];
-
-  for (const tool of tools) {
-    if (tool.type === "function") {
-      functionDeclarations.push({
-        name: tool.name,
-        ...(typeof tool.description === "string" ? { description: tool.description } : {}),
-        parameters: unwrapToolInputSchema(tool.inputSchema),
-      });
-      continue;
-    }
-
-    // Gemini provider tools — code_execution, google_search,
-    // google_search_retrieval — each lives in its own tools[] entry
-    // with a single key keyed by the camelCase tool name and an
-    // optional config payload (caller-provided tool.args).
-    if (!tool.id.startsWith("google.")) {
-      continue;
-    }
-    const providerType = tool.id.slice("google.".length);
-    if (providerType.length === 0) {
-      continue;
-    }
-    const camelKey = providerType.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
-    providerEntries.push({ [camelKey]: tool.args ?? {} });
-  }
-
-  const result: Array<Record<string, unknown>> = [];
-  if (functionDeclarations.length > 0) {
-    result.push({ functionDeclarations });
-  }
-  result.push(...providerEntries);
-  return result.length > 0 ? result : undefined;
-}
-
-function unwrapToolInputSchema(inputSchema: unknown): unknown {
+export function unwrapToolInputSchema(inputSchema: unknown): unknown {
   if (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema)) {
     return inputSchema;
   }
@@ -1576,375 +1402,6 @@ function unwrapToolInputSchema(inputSchema: unknown): unknown {
   return candidate ?? inputSchema;
 }
 
-function normalizeGoogleToolChoice(toolChoice: unknown):
-  | GoogleCompatibleRequest["toolConfig"]
-  | undefined {
-  if (toolChoice === undefined) {
-    return undefined;
-  }
-
-  if (typeof toolChoice === "string") {
-    switch (toolChoice) {
-      case "none":
-        return { functionCallingConfig: { mode: "NONE" } };
-      case "any":
-      case "required":
-        return { functionCallingConfig: { mode: "ANY" } };
-      default:
-        return { functionCallingConfig: { mode: "AUTO" } };
-    }
-  }
-
-  const record = readRecord(toolChoice);
-  if (!record) return undefined;
-
-  // Single-tool restriction: { type: "tool", name } — pin to one
-  // function via mode: ANY + allowedFunctionNames: [name].
-  if (record.type === "tool" && typeof record.name === "string") {
-    return {
-      functionCallingConfig: {
-        mode: "ANY",
-        allowedFunctionNames: [record.name],
-      },
-    };
-  }
-
-  // Multi-tool restriction: { type: "tools", names: string[] } — pin
-  // to a subset via mode: ANY + the full allowedFunctionNames array.
-  if (record.type === "tools" && Array.isArray(record.names)) {
-    const names = record.names.filter((n): n is string => typeof n === "string");
-    if (names.length > 0) {
-      return {
-        functionCallingConfig: {
-          mode: "ANY",
-          allowedFunctionNames: names,
-        },
-      };
-    }
-  }
-
-  // Explicit mode forms: { type: "auto" | "none" | "any" }.
-  if (record.type === "auto") {
-    return { functionCallingConfig: { mode: "AUTO" } };
-  }
-  if (record.type === "none") {
-    return { functionCallingConfig: { mode: "NONE" } };
-  }
-  if (record.type === "any" || record.type === "required") {
-    return { functionCallingConfig: { mode: "ANY" } };
-  }
-
-  return undefined;
-}
-
-/**
- * Map the unified reasoning option to Gemini's thinkingConfig. Gemini 2.5+
- * accepts `includeThoughts: true` to stream back `thought` parts, and
- * `thinkingBudget: N` to cap the thinking token count. The effort levels
- * here follow Google's own guidance (low ~= 512, medium ~= 2048,
- * high ~= 8192, max = -1 means "dynamic/no cap").
- */
-function resolveGoogleThinkingConfig(
-  option: ProviderReasoningOption | undefined,
-): Record<string, unknown> | undefined {
-  if (!option || option.enabled !== true) {
-    return undefined;
-  }
-  const config: Record<string, unknown> = { includeThoughts: true };
-  if (typeof option.budgetTokens === "number") {
-    config.thinkingBudget = option.budgetTokens;
-    return config;
-  }
-  switch (option.effort) {
-    case "low":
-      config.thinkingBudget = 512;
-      break;
-    case "high":
-      config.thinkingBudget = 8192;
-      break;
-    case "max":
-      config.thinkingBudget = -1;
-      break;
-    case "medium":
-    default:
-      config.thinkingBudget = 2048;
-      break;
-  }
-  return config;
-}
-
-function buildGoogleGenerationConfig(
-  options: OpenAICompatibleLanguageOptions,
-): Record<string, unknown> | undefined {
-  const thinkingConfig = resolveGoogleThinkingConfig(options.reasoning);
-  const config: Record<string, unknown> = {
-    ...(options.maxOutputTokens !== undefined ? { maxOutputTokens: options.maxOutputTokens } : {}),
-    ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
-    ...(options.topP !== undefined ? { topP: options.topP } : {}),
-    ...(options.topK !== undefined ? { topK: options.topK } : {}),
-    ...(options.stopSequences && options.stopSequences.length > 0
-      ? { stopSequences: options.stopSequences }
-      : {}),
-    ...(options.seed !== undefined ? { seed: options.seed } : {}),
-    ...(thinkingConfig ? { thinkingConfig } : {}),
-  };
-
-  return Object.keys(config).length > 0 ? config : undefined;
-}
-
-function buildGoogleGenerateContentRequest(
-  providerName: string,
-  options: OpenAICompatibleLanguageOptions,
-  warnings: WarningCollector,
-): GoogleCompatibleRequest {
-  // Google generate-content surface doesn't accept presence/frequency
-  // penalties on most current models. Emit warnings and let the request
-  // through without them.
-  if (options.presencePenalty !== undefined) {
-    warnings.push({
-      type: "unsupported-setting",
-      provider: "google",
-      setting: "presencePenalty",
-      details: "Gemini generateContent does not accept presencePenalty; the value was dropped.",
-    });
-  }
-  if (options.frequencyPenalty !== undefined) {
-    warnings.push({
-      type: "unsupported-setting",
-      provider: "google",
-      setting: "frequencyPenalty",
-      details: "Gemini generateContent does not accept frequencyPenalty; the value was dropped.",
-    });
-  }
-  if (options.responseFormat && options.responseFormat.type !== "text") {
-    warnings.push({
-      type: "unsupported-setting",
-      provider: "google",
-      setting: "responseFormat",
-      details:
-        "Gemini uses generationConfig.responseMimeType + responseSchema for structured outputs, which is a separate surface and not yet wired through this option.",
-    });
-  }
-
-  const { systemInstruction, contents } = toGoogleContents(options.prompt);
-  const generationConfig = buildGoogleGenerationConfig(options);
-  // requestLabels wins over userId-derived labels: when callers explicitly
-  // provide a label map, that's the source of truth. Otherwise fall back
-  // to {user_id} derived from the unified userId option.
-  const labels = options.requestLabels && Object.keys(options.requestLabels).length > 0
-    ? options.requestLabels
-    : typeof options.userId === "string" && options.userId.length > 0
-    ? { user_id: options.userId }
-    : undefined;
-  const body: GoogleCompatibleRequest = {
-    contents,
-    ...(systemInstruction ? { systemInstruction } : {}),
-    ...(toGoogleTools(options.tools) ? { tools: toGoogleTools(options.tools) } : {}),
-    ...(normalizeGoogleToolChoice(options.toolChoice)
-      ? { toolConfig: normalizeGoogleToolChoice(options.toolChoice) }
-      : {}),
-    ...(generationConfig ? { generationConfig } : {}),
-    ...(labels ? { labels } : {}),
-    ...(typeof options.googleCachedContent === "string" && options.googleCachedContent.length > 0
-      ? { cachedContent: options.googleCachedContent }
-      : {}),
-    ...(options.googleSafetySettings && options.googleSafetySettings.length > 0
-      ? { safetySettings: options.googleSafetySettings }
-      : {}),
-  };
-
-  Object.assign(body, readProviderOptions(options.providerOptions, "google", providerName));
-  return body;
-}
-
-function extractFirstGoogleCandidate(payload: unknown): Record<string, unknown> | undefined {
-  const record = readRecord(payload);
-  const candidates = record?.candidates;
-  if (!Array.isArray(candidates) || candidates.length === 0) {
-    return undefined;
-  }
-
-  return readRecord(candidates[0]);
-}
-
-function extractGoogleCandidateParts(payload: unknown): Array<Record<string, unknown>> {
-  const candidate = extractFirstGoogleCandidate(payload);
-  const content = readRecord(candidate?.content);
-  const parts = content?.parts;
-  if (!Array.isArray(parts)) {
-    return [];
-  }
-
-  return parts.flatMap((part) => {
-    const record = readRecord(part);
-    return record ? [record] : [];
-  });
-}
-
-function buildGoogleGenerateResult(payload: unknown): {
-  content: Array<
-    | { type: "text"; text: string }
-    | { type: "tool-call"; toolCallId: string; toolName: string; input: string }
-  >;
-  finishReason?: string | { unified: string; raw: string } | null;
-  usage?: RuntimeUsage;
-  groundingMetadata?: Record<string, unknown>;
-} {
-  const parts = extractGoogleCandidateParts(payload);
-  const content: Array<
-    | { type: "text"; text: string }
-    | { type: "tool-call"; toolCallId: string; toolName: string; input: string }
-  > = [];
-
-  for (const [index, part] of parts.entries()) {
-    if (typeof part.text === "string" && part.text.length > 0) {
-      content.push({ type: "text", text: part.text });
-      continue;
-    }
-
-    const functionCall = readRecord(part.functionCall);
-    if (typeof functionCall?.name === "string") {
-      content.push({
-        type: "tool-call",
-        toolCallId: typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`,
-        toolName: functionCall.name,
-        input: stringifyJsonValue(functionCall.args ?? {}),
-      });
-    }
-  }
-
-  // Gemini grounding (google_search / google_search_retrieval) returns
-  // a per-candidate groundingMetadata object with web search queries,
-  // grounding chunks, and citation indices into the response text.
-  // Pass it through opaquely so callers can render footnotes / source
-  // chips / "Search results" UI without parsing the wire shape.
-  const candidate = extractFirstGoogleCandidate(payload);
-  const groundingMetadata = readRecord(candidate?.groundingMetadata);
-
-  return {
-    content,
-    finishReason: normalizeGoogleFinishReason(candidate?.finishReason),
-    usage: extractGoogleUsage(payload),
-    ...(groundingMetadata ? { groundingMetadata } : {}),
-  };
-}
-
-async function* streamGoogleCompatibleParts(
-  stream: ReadableStream<Uint8Array>,
-): AsyncIterable<unknown> {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const seenToolCalls = new Set<string>();
-  let reasoningId: string | null = null;
-  let reasoningIndex = 0;
-  let finishReason: string | { unified: string; raw: string } | null = null;
-  let usage: RuntimeUsage | undefined;
-
-  for await (const chunk of stream) {
-    buffer += decoder.decode(chunk, { stream: true });
-    const parsed = parseSseChunk(buffer);
-    buffer = parsed.remainder;
-
-    for (const event of parsed.events) {
-      if (event === "[DONE]") {
-        continue;
-      }
-
-      usage = extractGoogleUsage(event) ?? usage;
-      const candidate = extractFirstGoogleCandidate(event);
-      const normalizedFinishReason = normalizeGoogleFinishReason(candidate?.finishReason);
-      if (normalizedFinishReason) {
-        finishReason = normalizedFinishReason;
-      }
-
-      for (const [index, part] of extractGoogleCandidateParts(event).entries()) {
-        const isThought = part.thought === true;
-        if (isThought && typeof part.text === "string" && part.text.length > 0) {
-          if (!reasoningId) {
-            reasoningId = `reasoning-${reasoningIndex++}`;
-            yield {
-              type: "reasoning-start",
-              id: reasoningId,
-            };
-          }
-
-          yield {
-            type: "reasoning-delta",
-            id: reasoningId,
-            delta: part.text,
-          };
-          continue;
-        }
-
-        if (reasoningId) {
-          yield {
-            type: "reasoning-end",
-            id: reasoningId,
-          };
-          reasoningId = null;
-        }
-
-        if (typeof part.text === "string" && part.text.length > 0) {
-          yield { type: "text-delta", delta: part.text };
-          continue;
-        }
-
-        const functionCall = readRecord(part.functionCall);
-        if (typeof functionCall?.name !== "string") {
-          continue;
-        }
-
-        const toolCallId = typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`;
-        if (seenToolCalls.has(toolCallId)) {
-          continue;
-        }
-
-        const serializedInput = stringifyJsonValue(functionCall.args ?? {});
-        seenToolCalls.add(toolCallId);
-        yield {
-          type: "tool-input-start",
-          id: toolCallId,
-          toolName: functionCall.name,
-        };
-        yield {
-          type: "tool-input-delta",
-          id: toolCallId,
-          delta: serializedInput,
-        };
-        yield {
-          type: "tool-call",
-          toolCallId,
-          toolName: functionCall.name,
-          input: serializedInput,
-        };
-      }
-    }
-  }
-
-  if (buffer.trim().length > 0) {
-    const parsed = parseSseChunk(`${buffer}\n\n`);
-    for (const event of parsed.events) {
-      if (event === "[DONE]") {
-        continue;
-      }
-      usage = extractGoogleUsage(event) ?? usage;
-    }
-  }
-
-  if (reasoningId) {
-    yield {
-      type: "reasoning-end",
-      id: reasoningId,
-    };
-  }
-
-  yield {
-    type: "finish",
-    finishReason,
-    ...(usage ? { usage } : {}),
-  };
-}
-
 export function createAnthropicModelRuntime(
   config: AnthropicRuntimeConfig,
   modelId: string,
@@ -2022,124 +1479,3 @@ export function createAnthropicModelRuntime(
     },
   };
 }
-
-export function createGoogleModelRuntime(
-  config: GoogleRuntimeConfig,
-  modelId: string,
-): ModelRuntime {
-  const fetchImpl = config.fetch ?? globalThis.fetch;
-  return {
-    provider: config.name ?? "google",
-    modelId,
-    specificationVersion: "v3",
-    supportedUrls: {},
-    doGenerate(optionsForRuntime: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      const url = getGoogleGenerateContentUrl(config.baseURL, modelId);
-      const warnings = createWarningCollector();
-      const body = buildGoogleGenerateContentRequest(
-        config.name ?? "google",
-        options,
-        warnings,
-      );
-      return requestJson({
-        url,
-        fetchImpl,
-        providerLabel: config.name ?? "google",
-        providerKind: "google",
-        init: createGoogleRequestInit({
-          apiKey: config.apiKey,
-          extraHeaders: options.headers,
-          body: JSON.stringify(body),
-          signal: options.abortSignal,
-        }),
-      }).then((payload) => {
-        const drained = warnings.drain();
-        return {
-          ...buildGoogleGenerateResult(payload),
-          ...(drained.length > 0 ? { warnings: drained } : {}),
-        };
-      });
-    },
-    doStream(optionsForRuntime: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      const url = getGoogleStreamGenerateContentUrl(config.baseURL, modelId);
-      const warnings = createWarningCollector();
-      const body = buildGoogleGenerateContentRequest(
-        config.name ?? "google",
-        options,
-        warnings,
-      );
-      return requestStream({
-        url,
-        fetchImpl,
-        providerLabel: config.name ?? "google",
-        providerKind: "google",
-        init: createGoogleRequestInit({
-          apiKey: config.apiKey,
-          extraHeaders: options.headers,
-          body: JSON.stringify(body),
-          signal: options.abortSignal,
-        }),
-      }).then((responseStream) => {
-        const drained = warnings.drain();
-        return {
-          stream: ReadableStream.from(
-            withToolInputStatusTransitions(streamGoogleCompatibleParts(responseStream)),
-          ),
-          ...(drained.length > 0 ? { warnings: drained } : {}),
-        };
-      });
-    },
-  };
-}
-
-export function createGoogleEmbeddingRuntime(
-  config: GoogleRuntimeConfig,
-  modelId: string,
-): EmbeddingRuntime {
-  const fetchImpl = config.fetch ?? globalThis.fetch;
-  return {
-    provider: config.name ?? "google",
-    modelId,
-    supportsParallelCalls: true,
-    doEmbed({ values, abortSignal }) {
-      if (values.length === 0) {
-        return Promise.resolve({
-          embeddings: [],
-          warnings: [],
-          rawResponse: { embeddings: [] },
-        });
-      }
-
-      const url = getGoogleEmbeddingUrl(config.baseURL, modelId);
-      return Promise.all(values.map((value) =>
-        requestJson({
-          url,
-          fetchImpl,
-          providerLabel: config.name ?? "google",
-          providerKind: "google",
-          init: createGoogleRequestInit({
-            apiKey: config.apiKey,
-            body: JSON.stringify({
-              content: {
-                parts: [{ text: value }],
-              },
-            }),
-            signal: abortSignal,
-          }),
-        })
-      )).then((payloads) => ({
-        embeddings: payloads.map(extractGoogleEmbedding),
-        usage: {
-          tokens: payloads.reduce<number>(
-            (total, payload) => total + (extractGoogleUsageTokens(payload) ?? 0),
-            0,
-          ),
-        },
-        rawResponse: payloads,
-        warnings: [],
-      }));
-    },
-  };
-}