@truefoundry/trueforge-core 0.0.0 → 0.1.0

package/dist/core/llm/VercelAILLM.js

@@ -0,0 +1,1037 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/llm/VercelAILLM.ts
+var VercelAILLM_exports = {};
+__export(VercelAILLM_exports, {
+  SUPPORTED_REASONING_EFFORTS: () => SUPPORTED_REASONING_EFFORTS,
+  VERCEL_AI_PROVIDER_NAMES: () => VERCEL_AI_PROVIDER_NAMES,
+  VercelAILLM: () => VercelAILLM,
+  buildLanguageModel: () => buildLanguageModel,
+  buildProviderOptions: () => buildProviderOptions,
+  buildStreamTextArgs: () => buildStreamTextArgs,
+  convertMessages: () => convertMessages,
+  convertTools: () => convertTools,
+  describeCallWarning: () => describeCallWarning,
+  describeStreamError: () => describeStreamError,
+  mapFinishReason: () => mapFinishReason,
+  mapStreamToChunks: () => mapStreamToChunks,
+  normalizeUsage: () => normalizeUsage,
+  parseMimeFromDataUri: () => parseMimeFromDataUri,
+  resolveMaxOutputTokens: () => resolveMaxOutputTokens,
+  shouldAttachReasoningSignature: () => shouldAttachReasoningSignature,
+  toAssistantModelMessage: () => toAssistantModelMessage,
+  toFilePart: () => toFilePart,
+  toReasoningLevel: () => toReasoningLevel,
+  toStreamError: () => toStreamError,
+  toStructuredOutputSpec: () => toStructuredOutputSpec,
+  toUserContent: () => toUserContent
+});
+module.exports = __toCommonJS(VercelAILLM_exports);
+var import_alibaba = require("@ai-sdk/alibaba");
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_google = require("@ai-sdk/google");
+var import_moonshotai = require("@ai-sdk/moonshotai");
+var import_openai = require("@ai-sdk/openai");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+var import_ai = require("ai");
+var import_errorLogFields = require("../util/errorLogFields.js");
+var import_LLMTypes = require("./LLMTypes.js");
+var VERCEL_AI_PROVIDER_NAMES = [
+  "openai",
+  "anthropic",
+  "google-gemini",
+  "fireworks",
+  "zai",
+  "moonshot",
+  "alibaba",
+  "together",
+  "custom"
+];
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isFunctionTool(tool) {
+  return tool.type === "function";
+}
+function isFunctionToolCall(toolCall) {
+  return toolCall.type === "function";
+}
+function compatibleModel(config) {
+  const { provider, model, apiKey, headers, baseUrl } = config;
+  if (baseUrl === void 0) {
+    throw new Error(`Provider "${provider.type}" requires a baseUrl`);
+  }
+  const client = (0, import_openai_compatible.createOpenAICompatible)({
+    name: provider.type,
+    baseURL: baseUrl,
+    apiKey,
+    // Without this the adapter silently downgrades json_schema to a schema-less json_object.
+    supportsStructuredOutputs: true,
+    // These endpoints omit token counts from streamed responses unless asked.
+    includeUsage: true,
+    ...Object.keys(headers).length > 0 ? { headers } : {}
+  });
+  return client(model.id);
+}
+function buildLanguageModel(config) {
+  const { provider, model, baseUrl, apiKey, headers } = config;
+  const extraHeaders = Object.keys(headers).length > 0 ? headers : void 0;
+  switch (provider.type) {
+    case "openai": {
+      const client = (0, import_openai.createOpenAI)({
+        apiKey,
+        ...baseUrl !== void 0 ? { baseURL: baseUrl } : {},
+        ...extraHeaders !== void 0 ? { headers: extraHeaders } : {}
+      });
+      return client.responses(model.id);
+    }
+    case "anthropic": {
+      const client = (0, import_anthropic.createAnthropic)({
+        apiKey,
+        ...baseUrl !== void 0 ? { baseURL: baseUrl } : {},
+        ...extraHeaders !== void 0 ? { headers: extraHeaders } : {}
+      });
+      return client(model.id);
+    }
+    case "google-gemini": {
+      const client = (0, import_google.createGoogle)({
+        apiKey,
+        ...baseUrl !== void 0 ? { baseURL: baseUrl } : {},
+        ...extraHeaders !== void 0 ? { headers: extraHeaders } : {}
+      });
+      return client(model.id);
+    }
+    case "moonshot": {
+      const client = (0, import_moonshotai.createMoonshotAI)({
+        apiKey,
+        ...baseUrl !== void 0 ? { baseURL: baseUrl } : {},
+        ...extraHeaders !== void 0 ? { headers: extraHeaders } : {}
+      });
+      return client(model.id);
+    }
+    case "alibaba": {
+      if (baseUrl === void 0) {
+        throw new Error(`Provider "alibaba" requires a baseUrl`);
+      }
+      const client = (0, import_alibaba.createAlibaba)({
+        apiKey,
+        baseURL: baseUrl,
+        ...extraHeaders !== void 0 ? { headers: extraHeaders } : {}
+      });
+      return client(model.id);
+    }
+    case "fireworks":
+    case "zai":
+    case "together":
+    case "custom": {
+      return compatibleModel(config);
+    }
+    default: {
+      const _exhaustive = provider.type;
+      throw new Error(`Unknown provider "${String(_exhaustive)}"`);
+    }
+  }
+}
+var COMMON_REASONING_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var VERCEL_AI_REASONING_LEVELS = [
+  "provider-default",
+  ...COMMON_REASONING_LEVELS
+];
+function isReasoningLevel(v) {
+  return VERCEL_AI_REASONING_LEVELS.some((level) => level === v);
+}
+var EFFORT_ALIASES = { max: "xhigh" };
+var SUPPORTED_REASONING_EFFORTS = [...COMMON_REASONING_LEVELS, "max"];
+function toReasoningLevel(reasoningEffort) {
+  if (reasoningEffort === void 0) {
+    return void 0;
+  }
+  const aliased = EFFORT_ALIASES[reasoningEffort];
+  if (aliased !== void 0) {
+    return aliased;
+  }
+  return isReasoningLevel(reasoningEffort) ? reasoningEffort : void 0;
+}
+function maxEffortOption(reasoningEffort) {
+  return reasoningEffort === "max" ? { reasoningEffort: "max" } : {};
+}
+function toStructuredOutputSpec(responseFormat) {
+  if (responseFormat === void 0 || responseFormat.type === "text") {
+    return { mode: "text" };
+  }
+  if (responseFormat.type === "json_object") {
+    return { mode: "json" };
+  }
+  const { json_schema } = responseFormat;
+  return {
+    mode: "json_schema",
+    schema: json_schema.schema ?? { type: "object", properties: {} },
+    name: json_schema.name,
+    description: json_schema.description,
+    strict: json_schema.strict ?? void 0
+  };
+}
+function buildOutput(spec) {
+  switch (spec.mode) {
+    case "text":
+      return void 0;
+    case "json":
+      return import_ai.Output.json();
+    case "json_schema":
+      return import_ai.Output.object({
+        schema: (0, import_ai.jsonSchema)(spec.schema),
+        name: spec.name,
+        ...spec.description !== void 0 ? { description: spec.description } : {}
+      });
+    default: {
+      const _exhaustive = spec;
+      throw new Error(`Unknown structured output mode: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+function readBodyField({ rawBody, key }) {
+  const val = Reflect.get(Object(rawBody), key);
+  return val !== void 0 ? val : void 0;
+}
+function openaiProviderOptions({
+  rawBody,
+  strictJsonSchema,
+  reasoningEffort
+}) {
+  const serviceTier = readBodyField({ rawBody, key: "service_tier" });
+  const user = readBodyField({ rawBody, key: "user" });
+  const promptCacheKey = readBodyField({ rawBody, key: "prompt_cache_key" });
+  const parallelToolCalls = readBodyField({ rawBody, key: "parallel_tool_calls" });
+  const reasoningSummary = readBodyField({ rawBody, key: "reasoning_summary" });
+  return {
+    store: false,
+    include: ["reasoning.encrypted_content"],
+    reasoningSummary: "auto",
+    // gpt-5.6 serves both xhigh and max, so the aliased top-level level asks for one rung less.
+    ...maxEffortOption(reasoningEffort),
+    ...reasoningSummary !== void 0 ? { reasoningSummary } : {},
+    ...strictJsonSchema !== void 0 ? { strictJsonSchema } : {},
+    ...serviceTier !== void 0 ? { serviceTier } : {},
+    ...user !== void 0 ? { user } : {},
+    ...promptCacheKey !== void 0 ? { promptCacheKey } : {},
+    ...parallelToolCalls !== void 0 ? { parallelToolCalls } : {}
+  };
+}
+function anthropicProviderOptions(rawBody) {
+  const cacheControl = readBodyField({ rawBody, key: "cache_control" }) ?? { type: "ephemeral" };
+  const disableParallelToolUse = readBodyField({ rawBody, key: "disable_parallel_tool_use" });
+  const thinking = readBodyField({ rawBody, key: "thinking" });
+  const effort = readBodyField({ rawBody, key: "effort" });
+  const opts = {
+    cacheControl,
+    ...disableParallelToolUse !== void 0 ? { disableParallelToolUse } : {},
+    ...thinking !== void 0 ? { thinking } : {},
+    ...effort !== void 0 ? { effort } : {}
+  };
+  return opts;
+}
+function googleGeminiThinkingConfig({
+  rawBody,
+  reasoningRequested
+}) {
+  const fromBody = readBodyField({ rawBody, key: "thinking_config" });
+  if (!reasoningRequested) {
+    return fromBody;
+  }
+  if (typeof fromBody === "object" && fromBody !== null && !Array.isArray(fromBody)) {
+    return { includeThoughts: true, ...fromBody };
+  }
+  return { includeThoughts: true };
+}
+function googleGeminiProviderOptions({
+  rawBody,
+  reasoningRequested
+}) {
+  const safetySettings = readBodyField({ rawBody, key: "safety_settings" });
+  const thinkingConfig = googleGeminiThinkingConfig({ rawBody, reasoningRequested });
+  const cachedContent = readBodyField({ rawBody, key: "cached_content" });
+  const opts = {
+    ...safetySettings !== void 0 ? { safetySettings } : {},
+    ...thinkingConfig !== void 0 ? { thinkingConfig } : {},
+    ...cachedContent !== void 0 ? { cachedContent } : {}
+  };
+  return Object.keys(opts).length > 0 ? opts : void 0;
+}
+function moonshotProviderOptions({
+  rawBody,
+  reasoningEffort
+}) {
+  const thinking = readBodyField({ rawBody, key: "thinking" });
+  const reasoningHistory = readBodyField({ rawBody, key: "reasoning_history" });
+  const opts = {
+    // Moonshot's own ceiling is `max`; the aliased `xhigh` is not one of its levels.
+    ...maxEffortOption(reasoningEffort),
+    ...thinking !== void 0 ? { thinking } : {},
+    ...reasoningHistory !== void 0 ? { reasoningHistory } : {}
+  };
+  return Object.keys(opts).length > 0 ? opts : void 0;
+}
+function alibabaProviderOptions(rawBody) {
+  const enableThinking = readBodyField({ rawBody, key: "enable_thinking" });
+  const thinkingBudget = readBodyField({ rawBody, key: "thinking_budget" });
+  const parallelToolCalls = readBodyField({ rawBody, key: "parallel_tool_calls" });
+  const opts = {
+    ...enableThinking !== void 0 ? { enableThinking } : {},
+    ...thinkingBudget !== void 0 ? { thinkingBudget } : {},
+    ...parallelToolCalls !== void 0 ? { parallelToolCalls } : {}
+  };
+  return Object.keys(opts).length > 0 ? opts : void 0;
+}
+var COMPATIBLE_BODY_FIELDS = [
+  "service_tier",
+  "user",
+  "prompt_cache_key",
+  "parallel_tool_calls",
+  "thinking",
+  "thinking_budget",
+  "enable_thinking",
+  "reasoning_history"
+];
+function compatibleProviderOptions({
+  strictJsonSchema,
+  reasoningEffort,
+  rawBody
+}) {
+  const forwarded = Object.fromEntries(
+    COMPATIBLE_BODY_FIELDS.flatMap((key) => {
+      const value = readBodyField({ rawBody, key });
+      return value === void 0 ? [] : [[key, value]];
+    })
+  );
+  const opts = {
+    // These endpoints discard an effort they do not recognise, and `xhigh` is one of those.
+    ...maxEffortOption(reasoningEffort),
+    ...forwarded,
+    ...strictJsonSchema !== void 0 ? { strictJsonSchema } : {}
+  };
+  return Object.keys(opts).length > 0 ? opts : void 0;
+}
+function buildProviderOptions({
+  config,
+  reasoningEffort,
+  structuredOutputSpec,
+  rawBody
+}) {
+  const strictJsonSchema = structuredOutputSpec.mode === "json_schema" ? structuredOutputSpec.strict : void 0;
+  if (config.provider.type === "openai") {
+    return { openai: openaiProviderOptions({ rawBody, strictJsonSchema, reasoningEffort }) };
+  } else if (config.provider.type === "anthropic") {
+    const anthropic = anthropicProviderOptions(rawBody);
+    return anthropic !== void 0 ? { anthropic } : {};
+  } else if (config.provider.type === "google-gemini") {
+    const google = googleGeminiProviderOptions({ rawBody, reasoningRequested: reasoningEffort !== void 0 });
+    return google !== void 0 ? { google } : {};
+  } else if (config.provider.type === "moonshot") {
+    const moonshotai = moonshotProviderOptions({ rawBody, reasoningEffort });
+    return moonshotai !== void 0 ? { moonshotai } : {};
+  } else if (config.provider.type === "alibaba") {
+    const alibaba = alibabaProviderOptions(rawBody);
+    return alibaba !== void 0 ? { alibaba } : {};
+  } else {
+    const compatible = compatibleProviderOptions({ strictJsonSchema, reasoningEffort, rawBody });
+    return compatible !== void 0 ? { [config.provider.type]: compatible } : {};
+  }
+}
+function resolveMaxOutputTokens(body) {
+  const limit = body.max_completion_tokens ?? Reflect.get(body, "max_tokens");
+  return typeof limit === "number" ? limit : void 0;
+}
+function parseMimeFromDataUri(uri) {
+  const match = /^data:([^;,]+)/.exec(uri);
+  return match?.[1];
+}
+function toFilePart(file) {
+  const { file_data, filename } = file;
+  if (!file_data) return void 0;
+  const mediaType = parseMimeFromDataUri(file_data) ?? "application/octet-stream";
+  return {
+    type: "file",
+    data: file_data,
+    mediaType,
+    ...filename !== void 0 ? { filename } : {}
+  };
+}
+function toUserContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      parts.push({ type: "text", text: part.text });
+      continue;
+    }
+    if (part.type === "image_url") {
+      const url = part.image_url.url;
+      const mediaType = parseMimeFromDataUri(url) ?? "image/*";
+      parts.push({ type: "file", data: url, mediaType });
+      continue;
+    }
+    if (part.type === "file") {
+      const filePart = toFilePart(part.file);
+      if (filePart !== void 0) {
+        parts.push(filePart);
+      }
+      continue;
+    }
+  }
+  return parts;
+}
+function toAssistantModelMessage({
+  msg,
+  provider,
+  providerName,
+  logger
+}) {
+  const parts = [];
+  const rawThinking = Reflect.get(msg, "thinking_blocks");
+  const attachSignature = shouldAttachReasoningSignature({
+    source: Reflect.get(msg, "source"),
+    provider,
+    providerName,
+    logger
+  });
+  if (Array.isArray(rawThinking) && provider !== "alibaba") {
+    const blocks = rawThinking;
+    for (const tb of blocks) {
+      if (typeof tb === "object" && tb !== null && "type" in tb && "thinking" in tb && tb.type === "thinking" && typeof tb.thinking === "string") {
+        const signature = "signature" in tb && typeof tb.signature === "string" ? tb.signature : void 0;
+        let reasoningProviderOptions;
+        if (signature !== void 0 && attachSignature) {
+          if (provider === "openai") {
+            reasoningProviderOptions = { openai: { reasoningEncryptedContent: signature } };
+          } else if (provider === "anthropic") {
+            reasoningProviderOptions = { anthropic: { signature } };
+          }
+        }
+        const reasoningPart = {
+          type: "reasoning",
+          text: tb.thinking,
+          ...reasoningProviderOptions !== void 0 ? { providerOptions: reasoningProviderOptions } : {}
+        };
+        parts.push(reasoningPart);
+      }
+    }
+  }
+  const rawContent = msg.content;
+  if (rawContent) {
+    const text = typeof rawContent === "string" ? rawContent : rawContent.filter((p) => p.type === "text").map((p) => p.text).join("");
+    if (text) {
+      const textPart = { type: "text", text };
+      parts.push(textPart);
+    }
+  }
+  if (msg.tool_calls?.length) {
+    for (const tc of msg.tool_calls) {
+      if (!isFunctionToolCall(tc)) {
+        continue;
+      }
+      let input = {};
+      try {
+        const parsed = JSON.parse(tc.function.arguments);
+        if (isPlainObject(parsed)) {
+          input = parsed;
+        }
+      } catch {
+      }
+      const rawProviderFields = Reflect.get(tc, "provider_specific_fields");
+      const thoughtSignature = isPlainObject(rawProviderFields) && typeof rawProviderFields["thought_signature"] === "string" ? rawProviderFields["thought_signature"] : void 0;
+      const toolCallPart = {
+        type: "tool-call",
+        toolCallId: tc.id,
+        toolName: tc.function.name,
+        input,
+        ...thoughtSignature !== void 0 ? { providerOptions: { google: { thoughtSignature } } } : {}
+      };
+      parts.push(toolCallPart);
+    }
+  }
+  return {
+    role: "assistant",
+    content: parts.length > 0 ? parts : [{ type: "text", text: "" }]
+  };
+}
+function parseAssistantMessageSource(source) {
+  const [providerType, providerName, modelName, ...rest] = source.split("/");
+  if (rest.length > 0 || !providerType || !providerName || !modelName) {
+    return void 0;
+  }
+  return { providerType, providerName, modelName };
+}
+function shouldAttachReasoningSignature({
+  source,
+  provider,
+  providerName,
+  logger
+}) {
+  if (source === void 0) {
+    return false;
+  }
+  if (typeof source !== "string") {
+    logger?.warn("Ignoring non-string assistant message source; skipping reasoning signature replay", { source });
+    return false;
+  }
+  const parsed = parseAssistantMessageSource(source);
+  if (parsed === void 0) {
+    logger?.warn("Ignoring malformed assistant message source; skipping reasoning signature replay", { source });
+    return false;
+  }
+  return parsed.providerType === provider && parsed.providerName === providerName;
+}
+function convertMessages({
+  messages,
+  provider,
+  providerName,
+  logger
+}) {
+  const toolNameById = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "assistant" && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        if (!isFunctionToolCall(tc)) {
+          continue;
+        }
+        toolNameById.set(tc.id, tc.function.name);
+      }
+    }
+  }
+  const systemParts = [];
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      const content = typeof msg.content === "string" ? msg.content : msg.content.map((p) => p.text).join("");
+      systemParts.push(content);
+      continue;
+    }
+    if (msg.role === "user") {
+      result.push({ role: "user", content: toUserContent(msg.content) });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      result.push(toAssistantModelMessage({ msg, provider, providerName, logger }));
+      continue;
+    }
+    if (msg.role === "tool") {
+      const toolName = toolNameById.get(msg.tool_call_id) ?? "";
+      const toolContent = [
+        {
+          type: "tool-result",
+          toolCallId: msg.tool_call_id,
+          toolName,
+          output: {
+            type: "text",
+            value: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          }
+        }
+      ];
+      result.push({ role: "tool", content: toolContent });
+      continue;
+    }
+  }
+  return { instructions: systemParts.length > 0 ? systemParts.join("\n\n") : void 0, messages: result };
+}
+function convertTools(tools) {
+  if (!tools?.length) {
+    return void 0;
+  }
+  const toolSet = {};
+  for (const t of tools) {
+    if (!isFunctionTool(t)) {
+      continue;
+    }
+    toolSet[t.function.name] = {
+      inputSchema: (0, import_ai.jsonSchema)(t.function.parameters ?? { type: "object", properties: {} }),
+      ...t.function.description !== void 0 ? { description: t.function.description } : {}
+    };
+  }
+  return Object.keys(toolSet).length > 0 ? toolSet : void 0;
+}
+function buildStreamTextArgs(input) {
+  const {
+    model,
+    instructions,
+    messages,
+    tools,
+    reasoning,
+    providerOptions,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    stopSequences,
+    seed,
+    abortSignal
+  } = input;
+  return {
+    model,
+    ...instructions !== void 0 ? { instructions } : {},
+    messages,
+    ...tools !== void 0 ? { tools } : {},
+    ...reasoning !== void 0 ? { reasoning } : {},
+    ...maxOutputTokens !== void 0 ? { maxOutputTokens } : {},
+    ...temperature != null ? { temperature } : {},
+    ...topP != null ? { topP } : {},
+    ...topK != null ? { topK } : {},
+    ...presencePenalty != null ? { presencePenalty } : {},
+    ...frequencyPenalty != null ? { frequencyPenalty } : {},
+    ...stopSequences != null ? { stopSequences } : {},
+    ...seed != null ? { seed } : {},
+    ...Object.keys(providerOptions).length > 0 ? { providerOptions } : {},
+    ...abortSignal !== void 0 ? { abortSignal } : {},
+    maxRetries: 0
+  };
+}
+function normalizeUsage(usage) {
+  const input = usage.inputTokens ?? 0;
+  const output = usage.outputTokens ?? 0;
+  const costInUsd = usage.raw?.["costInUSD"];
+  return {
+    input_tokens: input,
+    output_tokens: output,
+    total_tokens: input + output,
+    cache_read_tokens: usage.inputTokenDetails.cacheReadTokens ?? void 0,
+    cache_write_tokens: usage.inputTokenDetails.cacheWriteTokens ?? void 0,
+    reasoning_tokens: usage.outputTokenDetails.reasoningTokens ?? void 0,
+    cost_in_usd: typeof costInUsd === "number" && costInUsd >= 0 ? costInUsd : void 0
+  };
+}
+function describeStreamError(raw) {
+  if (import_ai.APICallError.isInstance(raw)) {
+    if (raw.statusCode != null) {
+      return `Request failed (${String(raw.statusCode)}): ${raw.message}`;
+    }
+    return raw.message;
+  }
+  return (0, import_errorLogFields.describeUnknownError)(raw);
+}
+function toStreamError(raw) {
+  if (raw instanceof Error) return raw;
+  return new Error(describeStreamError(raw), { cause: raw });
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool-calls":
+      return "tool_calls";
+    case "content-filter":
+      return "content_filter";
+    // No harness equivalent for these — fall back to 'stop'.
+    case "error":
+    case "other":
+      return "stop";
+    default: {
+      const _exhaustive = reason;
+      throw new Error(`Unknown finish reason: ${String(_exhaustive)}`);
+    }
+  }
+}
+function applyReasoningSignature({
+  block,
+  providerMetadata
+}) {
+  if (providerMetadata === void 0) {
+    return;
+  }
+  for (const meta of Object.values(providerMetadata)) {
+    if ("reasoningEncryptedContent" in meta && typeof meta["reasoningEncryptedContent"] === "string") {
+      block.signature = meta["reasoningEncryptedContent"];
+      return;
+    }
+    if ("signature" in meta && typeof meta["signature"] === "string") {
+      block.signature = meta["signature"];
+      return;
+    }
+  }
+}
+function reasoningItemId(providerMetadata) {
+  if (providerMetadata === void 0) {
+    return void 0;
+  }
+  for (const meta of Object.values(providerMetadata)) {
+    if ("itemId" in meta && typeof meta["itemId"] === "string") {
+      return meta["itemId"];
+    }
+  }
+  return void 0;
+}
+function describeCallWarning(warning) {
+  switch (warning.type) {
+    case "unsupported":
+    case "compatibility":
+      return warning.details !== void 0 ? `${warning.type}: ${warning.feature} (${warning.details})` : `${warning.type}: ${warning.feature}`;
+    case "deprecated":
+      return `deprecated: ${warning.setting} - ${warning.message}`;
+    case "other":
+      return `other: ${warning.message}`;
+    default: {
+      const _exhaustive = warning;
+      throw new Error(`Unknown call warning: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+async function* mapStreamToChunks({
+  stream,
+  chunkMeta
+}) {
+  const makeBase = () => ({
+    id: chunkMeta.id,
+    object: "chat.completion.chunk",
+    created: chunkMeta.created,
+    model: chunkMeta.model
+  });
+  const toolCallStates = /* @__PURE__ */ new Map();
+  let nextToolIndex = 0;
+  let accumulatedText = "";
+  const accumulatedThinking = [];
+  const thinkingByReasoningItem = /* @__PURE__ */ new Map();
+  let currentThinkingBlock = null;
+  const openThinkingBlock = (providerMetadata) => {
+    const itemId = reasoningItemId(providerMetadata);
+    const started = itemId !== void 0 ? thinkingByReasoningItem.get(itemId) : void 0;
+    if (started !== void 0) {
+      if (started.thinking.length > 0) {
+        started.thinking += "\n\n";
+      }
+      return started;
+    }
+    const block = { type: "thinking", thinking: "" };
+    accumulatedThinking.push(block);
+    if (itemId !== void 0) {
+      thinkingByReasoningItem.set(itemId, block);
+    }
+    return block;
+  };
+  let finalUsage = (0, import_LLMTypes.getEmptyUsage)();
+  let finalFinishReason = "stop";
+  for await (const part of stream) {
+    switch (part.type) {
+      case "text-delta": {
+        accumulatedText += part.text;
+        yield {
+          ...makeBase(),
+          choices: [
+            {
+              index: 0,
+              delta: { content: part.text, role: "assistant" },
+              finish_reason: null,
+              logprobs: null
+            }
+          ]
+        };
+        break;
+      }
+      case "reasoning-start": {
+        currentThinkingBlock = openThinkingBlock(part.providerMetadata);
+        break;
+      }
+      case "reasoning-delta": {
+        currentThinkingBlock ??= openThinkingBlock(part.providerMetadata);
+        currentThinkingBlock.thinking += part.text;
+        applyReasoningSignature({ block: currentThinkingBlock, providerMetadata: part.providerMetadata });
+        yield {
+          ...makeBase(),
+          choices: [
+            {
+              index: 0,
+              delta: {
+                thinking_blocks: [{ type: "thinking", thinking: part.text }],
+                reasoning_content: part.text
+              },
+              finish_reason: null,
+              logprobs: null
+            }
+          ]
+        };
+        break;
+      }
+      case "reasoning-end": {
+        if (currentThinkingBlock !== null) {
+          applyReasoningSignature({ block: currentThinkingBlock, providerMetadata: part.providerMetadata });
+        }
+        currentThinkingBlock = null;
+        break;
+      }
+      case "tool-input-start": {
+        const idx = nextToolIndex++;
+        const googleMeta = part.providerMetadata?.["google"];
+        const thoughtSignature = googleMeta !== void 0 && typeof googleMeta["thoughtSignature"] === "string" ? googleMeta["thoughtSignature"] : void 0;
+        toolCallStates.set(part.id, {
+          index: idx,
+          id: part.id,
+          name: part.toolName,
+          arguments: "",
+          thoughtSignature
+        });
+        yield {
+          ...makeBase(),
+          choices: [
+            {
+              index: 0,
+              delta: {
+                tool_calls: [
+                  {
+                    index: idx,
+                    id: part.id,
+                    type: "function",
+                    function: { name: part.toolName, arguments: "" }
+                  }
+                ]
+              },
+              finish_reason: null,
+              logprobs: null
+            }
+          ]
+        };
+        break;
+      }
+      case "tool-input-delta": {
+        const state = toolCallStates.get(part.id);
+        if (state === void 0) {
+          break;
+        }
+        state.arguments += part.delta;
+        yield {
+          ...makeBase(),
+          choices: [
+            {
+              index: 0,
+              delta: {
+                tool_calls: [{ index: state.index, function: { arguments: part.delta } }]
+              },
+              finish_reason: null,
+              logprobs: null
+            }
+          ]
+        };
+        break;
+      }
+      case "finish-step": {
+        finalUsage = normalizeUsage(part.usage);
+        finalFinishReason = mapFinishReason(part.finishReason);
+        yield {
+          ...makeBase(),
+          choices: [
+            {
+              index: 0,
+              delta: {},
+              finish_reason: finalFinishReason,
+              logprobs: null
+            }
+          ],
+          usage: finalUsage
+        };
+        break;
+      }
+      case "error": {
+        const raw = part.error;
+        const message = describeStreamError(raw);
+        const cause = raw instanceof Error ? raw : new Error(message);
+        throw new Error(message, { cause });
+      }
+      case "abort": {
+        const aborted = new Error("LLM stream aborted");
+        aborted.name = "AbortError";
+        throw aborted;
+      }
+      case "start":
+      case "text-start":
+      case "text-end":
+      case "custom":
+      case "tool-input-end":
+      case "source":
+      case "file":
+      case "reasoning-file":
+      case "tool-call":
+      case "tool-result":
+      case "tool-error":
+      case "tool-output-denied":
+      case "tool-approval-request":
+      case "tool-approval-response":
+      case "start-step":
+      case "finish":
+      case "raw":
+        break;
+      default: {
+        const _exhaustive = part;
+        throw new Error(`Unknown stream part type: ${JSON.stringify(_exhaustive)}`);
+      }
+    }
+  }
+  const toolCalls = [...toolCallStates.values()].sort((a, b) => a.index - b.index).map((tc) => ({
+    id: tc.id,
+    type: "function",
+    function: { name: tc.name, arguments: tc.arguments },
+    ...tc.thoughtSignature !== void 0 ? { provider_specific_fields: { thought_signature: tc.thoughtSignature } } : {}
+  }));
+  const output = {
+    role: "assistant",
+    content: accumulatedText || null,
+    ...accumulatedThinking.length > 0 ? { thinking_blocks: accumulatedThinking } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+  };
+  return { usage: finalUsage, output, finish_reason: finalFinishReason };
+}
+var VercelAILLM = class {
+  config;
+  logger;
+  signal;
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger;
+    this.signal = config.signal;
+  }
+  async *create(body) {
+    const { providerConfig } = this.config;
+    const languageModel = buildLanguageModel(providerConfig);
+    const { provider, model } = providerConfig;
+    const { instructions, messages } = convertMessages({
+      messages: body.messages,
+      provider: provider.type,
+      providerName: provider.name,
+      logger: this.logger
+    });
+    const tools = convertTools(body.tools ?? void 0);
+    const structuredOutputSpec = toStructuredOutputSpec(body.response_format);
+    const output = buildOutput(structuredOutputSpec);
+    const rawReasoningEffort = Reflect.get(body, "reasoning_effort");
+    const reasoningEffort = typeof rawReasoningEffort === "string" ? rawReasoningEffort : void 0;
+    const providerOptions = buildProviderOptions({
+      config: providerConfig,
+      reasoningEffort,
+      structuredOutputSpec,
+      rawBody: body
+    });
+    const reasoning = toReasoningLevel(reasoningEffort);
+    const rawTopK = Reflect.get(body, "top_k");
+    const rawSeed = Reflect.get(body, "seed");
+    const streamTextArgs = buildStreamTextArgs({
+      model: languageModel,
+      instructions,
+      messages,
+      tools,
+      reasoning,
+      providerOptions,
+      maxOutputTokens: resolveMaxOutputTokens(body),
+      temperature: body.temperature,
+      topP: body.top_p,
+      topK: typeof rawTopK === "number" ? rawTopK : null,
+      presencePenalty: body.presence_penalty,
+      frequencyPenalty: body.frequency_penalty,
+      stopSequences: typeof body.stop === "string" ? [body.stop] : body.stop ?? null,
+      seed: typeof rawSeed === "number" ? rawSeed : null,
+      abortSignal: this.signal
+    });
+    let streamResult;
+    try {
+      streamResult = (0, import_ai.streamText)({
+        ...streamTextArgs,
+        ...output !== void 0 ? { output } : {}
+      });
+    } catch (error) {
+      if (this.signal?.aborted) {
+        this.logger.debug("LLM call aborted", (0, import_errorLogFields.extractErrorLogFields)(error));
+      } else {
+        this.logger.error("Error creating streaming chat completion", (0, import_errorLogFields.extractErrorLogFields)(error));
+      }
+      throw toStreamError(error);
+    }
+    void streamResult.warnings.then(
+      (warnings) => {
+        if (warnings !== void 0 && warnings.length > 0) {
+          this.logger.warn("Provider adjusted the request", {
+            model: providerConfig.name,
+            warnings: warnings.map(describeCallWarning)
+          });
+        }
+      },
+      (reason) => {
+        this.logger.debug("Provider warnings unavailable", (0, import_errorLogFields.extractErrorLogFields)(reason));
+      }
+    );
+    const chunkMeta = {
+      id: `vc-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`,
+      created: Math.floor(Date.now() / 1e3),
+      model: providerConfig.name
+    };
+    try {
+      const result = yield* mapStreamToChunks({ stream: streamResult.stream, chunkMeta });
+      result.output.source = `${provider.type}/${provider.name}/${model.name}`;
+      return result;
+    } catch (error) {
+      if (this.signal?.aborted) {
+        this.logger.debug("LLM stream aborted", (0, import_errorLogFields.extractErrorLogFields)(error));
+      } else {
+        this.logger.error("Error reading LLM stream", (0, import_errorLogFields.extractErrorLogFields)(error));
+      }
+      throw toStreamError(error);
+    }
+  }
+  async createNonStream(body) {
+    const llmStream = this.create({ ...body, stream: true });
+    let result = await llmStream.next();
+    while (!result.done) {
+      result = await llmStream.next();
+    }
+    return result.value;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUPPORTED_REASONING_EFFORTS,
+  VERCEL_AI_PROVIDER_NAMES,
+  VercelAILLM,
+  buildLanguageModel,
+  buildProviderOptions,
+  buildStreamTextArgs,
+  convertMessages,
+  convertTools,
+  describeCallWarning,
+  describeStreamError,
+  mapFinishReason,
+  mapStreamToChunks,
+  normalizeUsage,
+  parseMimeFromDataUri,
+  resolveMaxOutputTokens,
+  shouldAttachReasoningSignature,
+  toAssistantModelMessage,
+  toFilePart,
+  toReasoningLevel,
+  toStreamError,
+  toStructuredOutputSpec,
+  toUserContent
+});
+//# sourceMappingURL=VercelAILLM.js.map