@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/api/anthropic-messages.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The Anthropic Messages adapter: request parameters, the event stream, and
+ * the simple reasoning mapping.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.ts";
+declare const ANTHROPIC_EFFORTS: readonly ["low", "medium", "high", "xhigh", "max"];
+export type AnthropicEffort = (typeof ANTHROPIC_EFFORTS)[number];
+export type AnthropicThinkingDisplay = "summarized" | "omitted";
+export interface AnthropicOptions extends StreamOptions {
+    /**
+     * Anthropic inference speed. Fast mode is available only for first-party
+     * Claude Opus 5 and Claude Opus 4.8 requests.
+     */
+    speed?: NonNullable<MessageCreateParamsStreaming["speed"]>;
+    /**
+     * Enable extended thinking.
+     * For adaptive thinking models: the model decides when/how much to think.
+     * For older models: uses budget-based thinking with thinkingBudgetTokens.
+     * Default: undefined (thinking is omitted unless `streamSimple()` maps
+     * a simple reasoning level to this option, or callers set it explicitly).
+     */
+    thinkingEnabled?: boolean;
+    /**
+     * Token budget for extended thinking (older models only).
+     * Ignored for adaptive thinking models.
+     * Default: 1024 when `thinkingEnabled` is true and no budget is provided.
+     */
+    thinkingBudgetTokens?: number;
+    /**
+     * Effort level for adaptive thinking models.
+     * Controls how much thinking Claude allocates:
+     * - "max": Always thinks with no constraints (Opus 4.6 only)
+     * - "xhigh": Highest reasoning level (Opus 4.7+, Fable 5)
+     * - "high": Always thinks, deep reasoning
+     * - "medium": Moderate thinking, may skip for simple queries
+     * - "low": Minimal thinking, skips for simple tasks
+     * Ignored for older models.
+     * Default: omitted unless `streamSimple()` maps a simple reasoning
+     * level to this option.
+     */
+    effort?: AnthropicEffort;
+    /**
+     * Controls how thinking content is returned in API responses.
+     * - "summarized": Thinking blocks contain summarized thinking text.
+     * - "omitted": Thinking blocks return an empty thinking field; the encrypted
+     *   signature still travels back for multi-turn continuity. Use for faster
+     *   time-to-first-text-token when your UI does not surface thinking.
+     *
+     * Note: Anthropic's API default for Claude Opus 4.7 and Claude Mythos Preview
+     * is "omitted". We default to "summarized" here to keep behavior consistent
+     * with older Claude 4 models. Set this explicitly to "omitted" to opt in.
+     * Default: "summarized" when thinking is enabled.
+     */
+    thinkingDisplay?: AnthropicThinkingDisplay;
+    /**
+     * Whether to request the interleaved thinking beta header for non-adaptive
+     * thinking models. Adaptive thinking models have interleaved thinking built in,
+     * so the header is skipped for them regardless of this setting.
+     * Default: true.
+     */
+    interleavedThinking?: boolean;
+    /**
+     * Anthropic tool choice behavior. String values map to Anthropic's built-in
+     * choices; `{ type: "tool", name }` forces a specific tool.
+     * Default: omitted (Anthropic default behavior, currently equivalent to auto).
+     */
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    /**
+     * Pre-built Anthropic client instance. When provided, skips internal client
+     * construction entirely. Use this to inject alternative SDK clients such as
+     * `AnthropicVertex` that shares the same messaging API.
+     */
+    client?: Anthropic;
+}
+export declare const stream: StreamFunction<"anthropic-messages", AnthropicOptions>;
+/**
+ * Maps a simple reasoning level onto Anthropic thinking. Adaptive models take an effort;
+ * budget models clamp the level to what the model supports before choosing a thinking-token
+ * budget. An undefined `maxTokens` means the caller set no output cap, so the model cap is
+ * used; it is never coerced to 0, which would make the thinking budget the whole `max_tokens`.
+ */
+export declare const streamSimple: StreamFunction<"anthropic-messages", SimpleStreamOptions>;
+export {};

package/dist/src/api/anthropic-messages.js

@@ -0,0 +1,578 @@
+import {
+  calculateCost2,
+  clampThinkingLevel2
+} from "../../chunks/account-limits-cache-zgzptd0z.js";
+import {
+  ANTHROPIC_FAST_MODE_COST_MULTIPLIER2
+} from "../../chunks/account-limits-cache-f9z00x8c.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+import {
+  resolveCacheRetention2
+} from "../../chunks/account-limits-cache-d2a51dka.js";
+import {
+  splitDeferredTools2
+} from "../../chunks/account-limits-cache-8s8bz4dr.js";
+import {
+  headersToRecord2
+} from "../../chunks/account-limits-cache-ag5b8dja.js";
+import {
+  repairJson2,
+  parseStreamingJson2,
+  parseToolCallArguments2
+} from "../../chunks/account-limits-cache-fbkaq46e.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+import {
+  retryProviderRequest2
+} from "../../chunks/account-limits-cache-nbhht7xz.js";
+import {
+  iterateServerSentEvents2
+} from "../../chunks/account-limits-cache-me1x57bs.js";
+import {
+  sanitizeSurrogates2
+} from "../../chunks/account-limits-cache-eqwweapz.js";
+import {
+  getSystemMessageText2
+} from "../../chunks/account-limits-cache-b4edaybk.js";
+import {
+  getCurrentTools2,
+  getDeclaredTools2,
+  getInitialSystemMessage2,
+  hasToolRedefinitions2,
+  resolveTranscript2
+} from "../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import {
+  runAssistantStream2
+} from "../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+import {
+  AnthropicEventSchema2,
+  AnthropicEventTypeSchema2,
+  IgnoredAnthropicEventSchema2
+} from "../../chunks/account-limits-cache-3ykqmnj5.js";
+import {
+  buildCopilotDynamicHeaders2
+} from "../../chunks/account-limits-cache-za42x8a3.js";
+import"../../chunks/account-limits-cache-dejeygdt.js";
+import {
+  clampMaxTokensToContext2,
+  buildBaseOptions2,
+  adjustMaxTokensForThinking2
+} from "../../chunks/account-limits-cache-k0pkzhbx.js";
+import {
+  transformMessages2
+} from "../../chunks/account-limits-cache-8qzk56vj.js";
+import {
+  toClaudeCodeName2,
+  fromClaudeCodeName2
+} from "../../chunks/account-limits-cache-ks1sjym9.js";
+import"../../chunks/account-limits-cache-ehy0ze2b.js";
+import {
+  claudeHeaderLimits2
+} from "../../chunks/account-limits-cache-re8hpzwn.js";
+import"../../chunks/account-limits-cache-hyzn1jmk.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import {
+  FAST_MODE_BETA2,
+  MID_CONVERSATION_TOOL_CHANGES_BETA2,
+  shouldUseServerSideFallbackBeta2,
+  getAnthropicCompat2,
+  mergeAnthropicHeaders2,
+  appendAnthropicBeta2,
+  assertRequestAuth2,
+  getAnthropicFederation2,
+  createClient2,
+  shouldUseFineGrainedToolStreamingBeta2
+} from "../../chunks/account-limits-cache-75smws02.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import {
+  normalizeToolCallId2,
+  convertMessages3,
+  convertTools3
+} from "../../chunks/account-limits-cache-4b8ckwqw.js";
+
+// src/api/anthropic-messages.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+function getCacheControl(model, cacheRetention, env) {
+  const retention = resolveCacheRetention2(cacheRetention, env);
+  if (retention === "none")
+    return;
+  const cacheControl = { type: "ephemeral" };
+  if (retention === "long" && getAnthropicCompat2(model).supportsLongCacheRetention) {
+    cacheControl.ttl = "1h";
+  }
+  return cacheControl;
+}
+var ANTHROPIC_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var DEFERRED_TOOL_PLACEHOLDER = {
+  name: "__pi_deferred_placeholder__",
+  description: "Reserved placeholder. Never available. Never call this.",
+  input_schema: { type: "object", properties: {}, required: [] },
+  defer_loading: true
+};
+function applyAnthropicFastModePricing(usage, fast) {
+  if (!fast)
+    return;
+  usage.cost.input *= ANTHROPIC_FAST_MODE_COST_MULTIPLIER2;
+  usage.cost.output *= ANTHROPIC_FAST_MODE_COST_MULTIPLIER2;
+  usage.cost.cacheRead *= ANTHROPIC_FAST_MODE_COST_MULTIPLIER2;
+  usage.cost.cacheWrite *= ANTHROPIC_FAST_MODE_COST_MULTIPLIER2;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function usesNativeToolChanges(model, context) {
+  const compat = getAnthropicCompat2(model);
+  const initialTools = getInitialSystemMessage2(context.messages)?.toolsAdded ?? [];
+  return compat.supportsMidConvoSystemMessages && compat.supportsMidConvoToolChanges && initialTools.length > 0 && !hasToolRedefinitions2(context.messages);
+}
+var AnthropicErrorEventSchema = Type.Object({
+  error: Type.Object({ type: Type.String(), message: Type.String() })
+});
+function anthropicErrorText(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (!Value.Check(AnthropicErrorEventSchema, parsed))
+      return data;
+    return parsed.error.message === "" ? parsed.error.type : parsed.error.message;
+  } catch {
+    return data;
+  }
+}
+async function* iterateAnthropicEvents(response, signal) {
+  if (!response.body) {
+    throw new Error("Attempted to iterate over an Anthropic response with no body");
+  }
+  let sawMessageStart = false;
+  let sawMessageEnd = false;
+  for await (const sse of iterateServerSentEvents2(response.body, signal)) {
+    if (sse.event === "error")
+      throw new Error(anthropicErrorText(sse.data));
+    if (!Value.Check(AnthropicEventTypeSchema2, sse.event))
+      continue;
+    try {
+      let event;
+      try {
+        event = JSON.parse(sse.data);
+      } catch {
+        event = JSON.parse(repairJson2(sse.data));
+      }
+      if (Value.Check(IgnoredAnthropicEventSchema2, event) && event.type === sse.event)
+        continue;
+      if (!Value.Check(AnthropicEventSchema2, event)) {
+        throw new Error("Invalid Anthropic event body");
+      }
+      if (event.type !== sse.event) {
+        throw new Error(`Event type ${event.type} does not match ${sse.event}`);
+      }
+      if (event.type === "message_start") {
+        sawMessageStart = true;
+      } else if (event.type === "message_stop") {
+        sawMessageEnd = true;
+      }
+      yield event;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+    }
+  }
+  if (sawMessageStart && !sawMessageEnd) {
+    throw new Error("Anthropic stream ended before message_stop");
+  }
+}
+var stream = (model, context, requested) => {
+  const options = requested?.fast === true && requested.speed === undefined ? { ...requested, speed: "fast" } : requested;
+  const normalizedContext = resolveTranscript2(context, getAnthropicCompat2(model).supportsMidConvoSystemMessages);
+  const currentTools = getCurrentTools2(normalizedContext.messages);
+  const nativeToolChanges = usesNativeToolChanges(model, normalizedContext);
+  return runAssistantStream2(model, options?.signal, "Anthropic", async (output, stream) => {
+    if (options?.speed === "fast" && !(model.provider === "anthropic" && model.modes?.includes("fast") === true)) {
+      throw new Error(`Anthropic fast mode is not available for ${model.provider}/${model.id}`);
+    }
+    let client;
+    let isOAuth;
+    let usageModel = model;
+    let usedFastMode = false;
+    if (options?.client) {
+      client = options.client;
+      isOAuth = false;
+    } else {
+      const apiKey = options?.apiKey;
+      const federation = getAnthropicFederation2(model, apiKey, options?.headers, options?.env);
+      if (!federation)
+        assertRequestAuth2(model.provider, apiKey, options?.headers);
+      let copilotDynamicHeaders;
+      if (model.provider === "github-copilot") {
+        copilotDynamicHeaders = buildCopilotDynamicHeaders2({
+          messages: normalizedContext.messages,
+          sessionId: options?.sessionId
+        });
+      }
+      const cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env);
+      const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+      const created = createClient2(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta2(model, normalizedContext), shouldUseServerSideFallbackBeta2(model), options?.speed === "fast", nativeToolChanges, options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId, federation);
+      client = created.client;
+      isOAuth = created.isOAuthToken;
+    }
+    const params = buildParams(model, normalizedContext, isOAuth, nativeToolChanges, options);
+    await options?.onPayload?.(params, model);
+    const requestOptions = {
+      signal: options?.signal,
+      maxRetries: 0
+    };
+    if (options?.timeoutMs !== undefined)
+      requestOptions.timeout = options.timeoutMs;
+    if (options?.client) {
+      const requestBetas = [
+        ...options.speed === "fast" ? [FAST_MODE_BETA2] : [],
+        ...nativeToolChanges ? [MID_CONVERSATION_TOOL_CHANGES_BETA2] : []
+      ];
+      if (requestBetas.length > 0) {
+        requestOptions.headers = requestBetas.reduce(appendAnthropicBeta2, mergeAnthropicHeaders2(model.headers, options.headers));
+      }
+    }
+    const response = await retryProviderRequest2(() => client.beta.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+      maxRetries: options?.maxRetries,
+      maxRetryDelayMs: options?.maxRetryDelayMs,
+      signal: options?.signal
+    });
+    const responseHeaders = headersToRecord2(response.headers);
+    await options?.onResponse?.({ status: response.status, headers: responseHeaders }, model);
+    if (options?.onAccountLimits !== undefined) {
+      const limits = claudeHeaderLimits2(responseHeaders, model.provider);
+      if (limits !== undefined)
+        await options.onAccountLimits(limits, model);
+    }
+    stream.push({ type: "start", partial: output });
+    const blocks = new Map;
+    for await (const event of iterateAnthropicEvents(response, options?.signal)) {
+      if (event.type === "message_start") {
+        output.responseId = event.message.id;
+        const responseModel = event.message.model;
+        if (responseModel !== model.id)
+          output.responseModel = responseModel;
+        const fallbackCost = responseModel === model.id ? undefined : model.compat?.allowedFallbackModels?.find((fallback) => fallback.provider === model.provider && fallback.model === responseModel)?.cost;
+        usageModel = fallbackCost ? { ...model, id: responseModel, cost: fallbackCost } : model;
+        usedFastMode = event.message.usage.speed === "fast";
+        output.usage.input = event.message.usage.input_tokens || 0;
+        output.usage.output = event.message.usage.output_tokens || 0;
+        output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
+        output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
+        output.usage.cacheWrite1h = event.message.usage.cache_creation?.ephemeral_1h_input_tokens || 0;
+        output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+        calculateCost2(usageModel, output.usage);
+        applyAnthropicFastModePricing(output.usage, usedFastMode);
+      } else if (event.type === "content_block_start") {
+        const content = event.content_block;
+        let block;
+        switch (content.type) {
+          case "text":
+            block = { type: "text", text: content.text ?? "" };
+            break;
+          case "thinking":
+            block = {
+              type: "thinking",
+              thinking: content.thinking ?? "",
+              thinkingSignature: content.signature ?? ""
+            };
+            break;
+          case "redacted_thinking":
+            block = {
+              type: "thinking",
+              thinking: "[Reasoning redacted]",
+              thinkingSignature: content.data,
+              redacted: true
+            };
+            break;
+          case "tool_use":
+            block = {
+              type: "toolCall",
+              id: content.id,
+              name: isOAuth ? fromClaudeCodeName2(content.name, currentTools) : content.name,
+              arguments: content.input ?? {}
+            };
+            break;
+        }
+        const contentIndex = output.content.push(block) - 1;
+        if (block.type === "toolCall") {
+          blocks.set(event.index, { kind: "toolCall", contentIndex, block, json: "" });
+          stream.push({ type: "toolcall_start", contentIndex, partial: output });
+        } else {
+          blocks.set(event.index, { kind: "content", contentIndex, block });
+          stream.push({
+            type: block.type === "text" ? "text_start" : "thinking_start",
+            contentIndex,
+            partial: output
+          });
+        }
+      } else if (event.type === "content_block_delta") {
+        const slot = blocks.get(event.index);
+        if (!slot)
+          continue;
+        const { block, contentIndex } = slot;
+        const delta = event.delta;
+        if (delta.type === "text_delta" && block.type === "text") {
+          block.text += delta.text;
+          stream.push({ type: "text_delta", contentIndex, delta: delta.text, partial: output });
+        } else if (delta.type === "thinking_delta" && block.type === "thinking") {
+          block.thinking += delta.thinking;
+          stream.push({
+            type: "thinking_delta",
+            contentIndex,
+            delta: delta.thinking,
+            partial: output
+          });
+        } else if (delta.type === "input_json_delta" && slot.kind === "toolCall") {
+          slot.json += delta.partial_json;
+          slot.block.arguments = parseStreamingJson2(slot.json);
+          stream.push({
+            type: "toolcall_delta",
+            contentIndex,
+            delta: delta.partial_json,
+            partial: output
+          });
+        } else if (delta.type === "signature_delta" && block.type === "thinking") {
+          block.thinkingSignature = (block.thinkingSignature ?? "") + delta.signature;
+        }
+      } else if (event.type === "content_block_stop") {
+        const slot = blocks.get(event.index);
+        if (!slot)
+          continue;
+        blocks.delete(event.index);
+        const { block, contentIndex } = slot;
+        if (slot.kind === "toolCall") {
+          if (slot.json.length > 0)
+            Object.assign(slot.block, parseToolCallArguments2(slot.json));
+          stream.push({
+            type: "toolcall_end",
+            contentIndex,
+            toolCall: slot.block,
+            partial: output
+          });
+        } else if (block.type === "text") {
+          stream.push({ type: "text_end", contentIndex, content: block.text, partial: output });
+        } else if (block.type === "thinking") {
+          stream.push({
+            type: "thinking_end",
+            contentIndex,
+            content: block.thinking,
+            partial: output
+          });
+        }
+      } else if (event.type === "message_delta") {
+        if (event.delta.stop_reason) {
+          output.rawStopReason = event.delta.stop_reason;
+          const stopReasonResult = mapStopReason(event.delta);
+          output.stopReason = stopReasonResult.stopReason;
+          if (stopReasonResult.errorMessage) {
+            output.errorMessage = stopReasonResult.errorMessage;
+          }
+        }
+        if (event.usage) {
+          if (event.usage.input_tokens != null) {
+            output.usage.input = event.usage.input_tokens;
+          }
+          if (event.usage.output_tokens != null) {
+            output.usage.output = event.usage.output_tokens;
+          }
+          if (event.usage.cache_read_input_tokens != null) {
+            output.usage.cacheRead = event.usage.cache_read_input_tokens;
+          }
+          if (event.usage.cache_creation_input_tokens != null) {
+            output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
+          }
+          const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
+          if (thinkingTokens != null) {
+            output.usage.reasoning = thinkingTokens;
+          }
+        }
+        output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+        calculateCost2(usageModel, output.usage);
+        applyAnthropicFastModePricing(output.usage, usedFastMode);
+      }
+    }
+  }, (error) => error instanceof Error ? error.message : JSON.stringify(error));
+};
+function mapThinkingLevelToEffort(model, level) {
+  const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+  const mappedEffort = ANTHROPIC_EFFORTS.find((effort) => effort === mapped);
+  if (mappedEffort !== undefined)
+    return mappedEffort;
+  switch (level) {
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    default:
+      return "high";
+  }
+}
+var streamSimple = (model, context, options) => {
+  if (!getAnthropicFederation2(model, options?.apiKey, options?.headers, options?.env)) {
+    assertRequestAuth2(model.provider, options?.apiKey, options?.headers);
+  }
+  const base = buildBaseOptions2(model, context, options);
+  if (!options?.reasoning) {
+    return stream(model, context, {
+      ...base,
+      thinkingEnabled: false
+    });
+  }
+  if (model.compat?.forceAdaptiveThinking === true) {
+    const effort = mapThinkingLevelToEffort(model, options.reasoning);
+    return stream(model, context, {
+      ...base,
+      thinkingEnabled: true,
+      effort
+    });
+  }
+  const reasoning = clampThinkingLevel2(model, options.reasoning);
+  if (reasoning === "off") {
+    return stream(model, context, {
+      ...base,
+      thinkingEnabled: false
+    });
+  }
+  const adjusted = adjustMaxTokensForThinking2(base.maxTokens, model.maxTokens, reasoning, options.thinkingBudgets);
+  const maxTokens = clampMaxTokensToContext2(model, context, adjusted.maxTokens);
+  return stream(model, context, {
+    ...base,
+    maxTokens,
+    thinkingEnabled: true,
+    thinkingBudgetTokens: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024))
+  });
+};
+function systemBlock(text, cacheControl) {
+  const block = { type: "text", text };
+  if (cacheControl)
+    block.cache_control = cacheControl;
+  return block;
+}
+var AnthropicMetadataSchema = Type.Object({ user_id: Type.String() });
+function buildParams(model, context, isOAuthToken, nativeToolChanges, options) {
+  const cacheControl = getCacheControl(model, options?.cacheRetention, options?.env);
+  const compat = getAnthropicCompat2(model);
+  const initialSystemMessage = getInitialSystemMessage2(context.messages);
+  const initialSystemText = initialSystemMessage ? getSystemMessageText2(initialSystemMessage) : "";
+  const transformedMessages = transformMessages2(context.messages, model, normalizeToolCallId2);
+  const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;
+  const normalizeToolName = isOAuthToken ? toClaudeCodeName2 : (name) => name;
+  const initialTools = initialSystemMessage?.toolsAdded ?? [];
+  const toolPlacement = splitDeferredTools2({ messages: conversationMessages, tools: getCurrentTools2(context.messages) }, compat.supportsToolReferences && !nativeToolChanges, normalizeToolName);
+  let immediateTools = toolPlacement.immediate;
+  let deferredTools = [...toolPlacement.deferred.values()];
+  if (immediateTools.length === 0 && deferredTools.length > 0) {
+    immediateTools = deferredTools;
+    deferredTools = [];
+  }
+  const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
+  const params = {
+    model: model.id,
+    messages: convertMessages3(conversationMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName, nativeToolChanges),
+    max_tokens: options?.maxTokens ?? model.maxTokens,
+    stream: true
+  };
+  if (options?.speed !== undefined) {
+    params.speed = options.speed;
+  }
+  if (isOAuthToken) {
+    params.system = [
+      systemBlock("You are Claude Code, Anthropic's official CLI for Claude.", cacheControl)
+    ];
+    if (initialSystemText) {
+      params.system.push(systemBlock(sanitizeSurrogates2(initialSystemText), cacheControl));
+    }
+  } else if (initialSystemText) {
+    params.system = [systemBlock(sanitizeSurrogates2(initialSystemText), cacheControl)];
+  }
+  if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
+    params.temperature = options.temperature;
+  }
+  const toolCacheControl = compat.supportsCacheControlOnTools ? cacheControl : undefined;
+  if (nativeToolChanges) {
+    const initialNames = new Set(initialTools.map((tool) => tool.name));
+    const laterTools = getDeclaredTools2(context.messages).filter((tool) => !initialNames.has(tool.name));
+    params.tools = [
+      ...convertTools3(initialTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+      DEFERRED_TOOL_PLACEHOLDER,
+      ...convertTools3(laterTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools).map((tool) => ({ ...tool, defer_loading: true }))
+    ];
+  } else if (immediateTools.length > 0 || deferredTools.length > 0) {
+    params.tools = [
+      ...convertTools3(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+      ...convertTools3(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true)
+    ];
+  }
+  if (model.reasoning) {
+    if (options?.thinkingEnabled) {
+      const display = options.thinkingDisplay ?? "summarized";
+      if (model.compat?.forceAdaptiveThinking === true) {
+        params.thinking = { type: "adaptive", display };
+        if (options.effort) {
+          params.output_config = { effort: options.effort };
+        }
+      } else {
+        params.thinking = {
+          type: "enabled",
+          budget_tokens: options.thinkingBudgetTokens || 1024,
+          display
+        };
+      }
+    } else if (options?.thinkingEnabled === false && model.thinkingLevelMap?.off !== null) {
+      params.thinking = { type: "disabled" };
+    }
+  }
+  const metadata = options?.metadata;
+  if (Value.Check(AnthropicMetadataSchema, metadata)) {
+    params.metadata = { user_id: metadata.user_id };
+  }
+  const toolChoice = options?.toolChoice;
+  switch (toolChoice) {
+    case undefined:
+      break;
+    case "auto":
+    case "any":
+    case "none":
+      params.tool_choice = { type: toolChoice };
+      break;
+    default:
+      params.tool_choice = toolChoice;
+  }
+  const allowedFallbackModels = model.compat?.allowedFallbackModels;
+  if (allowedFallbackModels && allowedFallbackModels.length > 0) {
+    params.fallbacks = allowedFallbackModels.map((fallback) => ({ model: fallback.model }));
+  }
+  return params;
+}
+function mapStopReason(delta) {
+  const reason = delta.stop_reason;
+  switch (reason) {
+    case "end_turn":
+      return { stopReason: "stop" };
+    case "max_tokens":
+      return { stopReason: "length" };
+    case "tool_use":
+      return { stopReason: "toolUse" };
+    case "refusal":
+      return {
+        stopReason: "error",
+        errorMessage: delta.stop_details?.explanation || `The model refused to complete the request`
+      };
+    case "pause_turn":
+      return { stopReason: "stop" };
+    case "stop_sequence":
+      return { stopReason: "stop" };
+    case "sensitive":
+      return { stopReason: "error", errorMessage: "Provider stopped with: sensitive" };
+    default:
+      throw new Error(`Unhandled stop reason: ${reason}`);
+  }
+}
+export {
+  stream,
+  streamSimple
+};

package/dist/src/api/anthropic-messages.lazy.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderStreams } from "../types.ts";
+export declare const anthropicMessagesApi: () => ProviderStreams;

package/dist/src/api/anthropic-messages.lazy.js

@@ -0,0 +1,11 @@
+import {
+  anthropicMessagesApi2
+} from "../../chunks/account-limits-cache-zqdb4yh4.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  anthropicMessagesApi2 as anthropicMessagesApi
+};