@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-zcbkmrvy.js

@@ -0,0 +1,79 @@
+// src/utils/error-body.ts
+var MAX_PROVIDER_ERROR_BODY_CHARS2 = 4000;
+function normalizeProviderError2(cause) {
+  if (!(cause instanceof Error)) {
+    return { message: safeJsonStringify(cause), messageCarriesBody: false };
+  }
+  const status = extractStatus(cause);
+  const body = extractBody(cause);
+  const messageCarriesBody = body === undefined || cause.message.includes(body);
+  return {
+    status,
+    body,
+    message: cause.message,
+    messageCarriesBody
+  };
+}
+function extractStatus(error) {
+  if (typeof error.statusCode === "number")
+    return error.statusCode;
+  if (typeof error.status === "number")
+    return error.status;
+  if (typeof error.$metadata?.httpStatusCode === "number")
+    return error.$metadata.httpStatusCode;
+  if (typeof error.$response?.statusCode === "number")
+    return error.$response.statusCode;
+  return;
+}
+function extractBody(error) {
+  const bodyText = pickBodyText(error);
+  if (bodyText === undefined)
+    return;
+  const trimmed = bodyText.trim();
+  if (trimmed.length === 0)
+    return;
+  return truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS2);
+}
+function pickBodyText(error) {
+  if (typeof error.body === "string")
+    return error.body;
+  if (plainObjectWithFields(error.error))
+    return safeJsonStringify(error.error);
+  const responseBody = error.$response?.body;
+  if (typeof responseBody === "string")
+    return responseBody;
+  if (typeof responseBody === "object" && responseBody !== null && "pipe" in responseBody && typeof responseBody.pipe === "function")
+    return;
+  if (plainObjectWithFields(responseBody))
+    return safeJsonStringify(responseBody);
+  return;
+}
+function plainObjectWithFields(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return false;
+  return Object.keys(value).length > 0;
+}
+function formatProviderError2(norm, prefix) {
+  if (norm.messageCarriesBody || norm.status === undefined || norm.body === undefined) {
+    return prefix !== undefined && norm.status !== undefined ? `${prefix} (${norm.status}): ${norm.message}` : norm.message;
+  }
+  return prefix !== undefined ? `${prefix} (${norm.status}): ${norm.body}` : `${norm.status}: ${norm.body}`;
+}
+function truncateErrorText(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
+  return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function safeJsonStringify(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+export { MAX_PROVIDER_ERROR_BODY_CHARS2, normalizeProviderError2, formatProviderError2 };

package/dist/chunks/account-limits-cache-zgzptd0z.js

@@ -0,0 +1,62 @@
+// src/model-capabilities.ts
+import { MODEL_THINKING_LEVELS } from "@nyte-ai/schema/model";
+function hasApi2(model, api) {
+  return model.api === api;
+}
+function calculateCost2(model, usage) {
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+  let rates = model.cost;
+  let matchedThreshold = -1;
+  for (const tier of model.cost.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      rates = tier;
+      matchedThreshold = tier.inputTokensAbove;
+    }
+  }
+  const longWrite = usage.cacheWrite1h ?? 0;
+  const shortWrite = usage.cacheWrite - longWrite;
+  usage.cost.input = rates.input / 1e6 * usage.input;
+  usage.cost.output = rates.output / 1e6 * usage.output;
+  usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+  usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage.cost;
+}
+function getSupportedThinkingLevels2(model) {
+  if (!model.reasoning)
+    return ["off"];
+  return MODEL_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null)
+      return false;
+    if (level === "xhigh" || level === "max")
+      return mapped !== undefined;
+    return true;
+  });
+}
+function clampThinkingLevel2(model, level) {
+  const availableLevels = getSupportedThinkingLevels2(model);
+  if (availableLevels.includes(level))
+    return level;
+  const requestedIndex = MODEL_THINKING_LEVELS.findIndex((candidate) => candidate === level);
+  if (requestedIndex === -1)
+    return availableLevels[0] ?? "off";
+  for (let i = requestedIndex;i < MODEL_THINKING_LEVELS.length; i++) {
+    const candidate = MODEL_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate))
+      return candidate;
+  }
+  for (let i = requestedIndex - 1;i >= 0; i--) {
+    const candidate = MODEL_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate))
+      return candidate;
+  }
+  return availableLevels[0] ?? "off";
+}
+function modelsAreEqual2(a, b) {
+  if (!a || !b)
+    return false;
+  return a.id === b.id && a.provider === b.provider;
+}
+
+export { hasApi2, calculateCost2, getSupportedThinkingLevels2, clampThinkingLevel2, modelsAreEqual2 };

package/dist/chunks/account-limits-cache-zn01kscn.js

@@ -0,0 +1,252 @@
+import {
+  resolveCacheRetention2
+} from "./account-limits-cache-d2a51dka.js";
+import {
+  getDeclaredTools2,
+  resolveTranscriptTools2
+} from "./account-limits-cache-6250ykn6.js";
+import {
+  createGrammarToolInputProperties2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  clampOpenAIPromptCacheKey2
+} from "./account-limits-cache-csbxvam7.js";
+import {
+  thinkingBudgetForLevel2,
+  clampThinkingBudgetToAnswerRoom2
+} from "./account-limits-cache-k0pkzhbx.js";
+import {
+  resolveCompat2,
+  getCompatCacheControl2,
+  applyAnthropicCacheControl2,
+  convertMessages2,
+  convertTools2
+} from "./account-limits-cache-fdwad56n.js";
+
+// src/api/openai-completions-params.ts
+function hasToolHistory(messages) {
+  for (const msg of messages) {
+    if (msg.role === "toolResult") {
+      return true;
+    }
+    if (msg.role === "assistant") {
+      if (msg.content.some((block) => block.type === "toolCall")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getDeferredToolNames(messages) {
+  const names = new Set;
+  for (const message of messages) {
+    if (message.role === "toolResult") {
+      for (const name of message.addedToolNames ?? []) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
+function buildParams2(model, context, options, compat = resolveCompat2(model), cacheRetention = resolveCacheRetention2(options?.cacheRetention, options?.env), grammarToolInputProperties = createGrammarToolInputProperties2(getDeclaredTools2(context.messages), compat.supportsOpenAIGrammarTools)) {
+  const transcriptTools = resolveTranscriptTools2(context.messages, compat.supportsMidConvoSystemMessages === true && compat.supportsMidConvoToolAdditions === true);
+  const messages = convertMessages2(model, context, compat, { grammarToolInputProperties });
+  const cacheControl = getCompatCacheControl2(compat, cacheRetention);
+  const params = {
+    model: model.id,
+    messages,
+    stream: true,
+    prompt_cache_key: model.baseUrl.includes("api.openai.com") && cacheRetention !== "none" || cacheRetention === "long" && compat.supportsLongCacheRetention ? clampOpenAIPromptCacheKey2(options?.sessionId) : undefined,
+    prompt_cache_retention: cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined
+  };
+  if (compat.supportsUsageInStreaming !== false) {
+    params.stream_options = { include_usage: true };
+  }
+  if (compat.supportsStore) {
+    params.store = false;
+  }
+  if (options?.maxTokens) {
+    if (compat.maxTokensField === "max_tokens") {
+      params.max_tokens = options.maxTokens;
+    } else {
+      params.max_completion_tokens = options.maxTokens;
+    }
+  }
+  if (options?.temperature !== undefined) {
+    params.temperature = options.temperature;
+  }
+  const deferredToolNames = compat.deferredToolsMode === "kimi" ? getDeferredToolNames(context.messages) : new Set;
+  const activeTools = transcriptTools.requestTools.filter((tool) => !deferredToolNames.has(tool.name));
+  if (activeTools.length > 0) {
+    params.tools = convertTools2(activeTools, compat);
+    if (compat.zaiToolStream) {
+      Object.assign(params, { tool_stream: true });
+    }
+  } else if (hasToolHistory(context.messages)) {
+    params.tools = [];
+  }
+  if (cacheControl) {
+    applyAnthropicCacheControl2(messages, params.tools, cacheControl);
+  }
+  if (options?.toolChoice) {
+    params.tool_choice = options.toolChoice;
+  }
+  const thinkingTokenBudgetField = resolveThinkingTokenBudgetField(compat);
+  const thinkingBudget = resolveClampedThinkingBudget(model, options, params);
+  if (compat.thinkingFormat === "zai" && model.reasoning) {
+    Object.assign(params, {
+      thinking: options?.reasoningEffort ? { type: "enabled", clear_thinking: false } : { type: "disabled" }
+    });
+    if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+      const mappedEffort = model.thinkingLevelMap?.[options.reasoningEffort];
+      const effort = mappedEffort === undefined ? options.reasoningEffort : mappedEffort;
+      if (effort !== null)
+        Object.assign(params, { reasoning_effort: effort });
+    }
+  } else if (compat.thinkingFormat === "qwen" && model.reasoning) {
+    Object.assign(params, { enable_thinking: !!options?.reasoningEffort });
+    if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+      Object.assign(params, {
+        reasoning_effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+      });
+    }
+  } else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) {
+    Object.assign(params, {
+      chat_template_kwargs: {
+        enable_thinking: !!options?.reasoningEffort,
+        preserve_thinking: true
+      }
+    });
+  } else if (compat.thinkingFormat === "chat-template" && model.reasoning) {
+    const chatTemplateKwargs = buildChatTemplateValues(model, options, compat.chatTemplateKwargs, thinkingBudget);
+    if (chatTemplateKwargs) {
+      Object.assign(params, { chat_template_kwargs: chatTemplateKwargs });
+    }
+  } else if (compat.thinkingFormat === "baseten" && model.reasoning) {
+    const chatTemplateArgs = buildChatTemplateValues(model, options, compat.chatTemplateArgs, thinkingBudget);
+    if (chatTemplateArgs) {
+      Object.assign(params, { chat_template_args: chatTemplateArgs });
+    }
+    if (compat.supportsReasoningEffort) {
+      const requestedEffort = options?.reasoningEffort;
+      const mappedEffort = requestedEffort ? model.thinkingLevelMap?.[requestedEffort] : model.thinkingLevelMap?.off;
+      const effort = mappedEffort === undefined ? requestedEffort : mappedEffort;
+      if (effort !== null && effort !== undefined) {
+        Object.assign(params, { reasoning_effort: effort });
+      }
+    }
+  } else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
+    if (options?.reasoningEffort) {
+      Object.assign(params, { thinking: { type: "enabled" } });
+    } else if (model.thinkingLevelMap?.off !== null) {
+      Object.assign(params, { thinking: { type: "disabled" } });
+    }
+    if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+      Object.assign(params, {
+        reasoning_effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+      });
+    }
+  } else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
+    if (options?.reasoningEffort) {
+      Object.assign(params, {
+        reasoning: {
+          effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+        }
+      });
+    } else if (model.thinkingLevelMap?.off !== null) {
+      Object.assign(params, { reasoning: { effort: model.thinkingLevelMap?.off ?? "none" } });
+    }
+  } else if (compat.thinkingFormat === "ant-ling" && model.reasoning && options?.reasoningEffort) {
+    const effort = model.thinkingLevelMap?.[options.reasoningEffort];
+    if (effort !== null && effort !== undefined)
+      Object.assign(params, { reasoning: { effort } });
+  } else if (compat.thinkingFormat === "together" && model.reasoning) {
+    Object.assign(params, { reasoning: { enabled: !!options?.reasoningEffort } });
+    if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+      Object.assign(params, {
+        reasoning_effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+      });
+    }
+  } else if (compat.thinkingFormat === "string-thinking" && model.reasoning) {
+    if (options?.reasoningEffort) {
+      Object.assign(params, {
+        thinking: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+      });
+    } else if (model.thinkingLevelMap?.off !== null) {
+      Object.assign(params, { thinking: model.thinkingLevelMap?.off ?? "none" });
+    }
+  } else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+    Object.assign(params, {
+      reasoning_effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort
+    });
+  } else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+    const offValue = model.thinkingLevelMap?.off;
+    if (offValue !== null && offValue !== undefined) {
+      Object.assign(params, { reasoning_effort: offValue });
+    }
+  }
+  if (thinkingTokenBudgetField && thinkingBudget !== undefined) {
+    Object.assign(params, { [thinkingTokenBudgetField]: thinkingBudget });
+  }
+  if (model.compat?.openRouterRouting) {
+    Object.assign(params, { provider: model.compat.openRouterRouting });
+  }
+  if (model.compat?.vercelGatewayRouting) {
+    const routing = model.compat.vercelGatewayRouting;
+    if (routing.only || routing.order) {
+      const gatewayOptions = {};
+      if (routing.only)
+        gatewayOptions.only = routing.only;
+      if (routing.order)
+        gatewayOptions.order = routing.order;
+      Object.assign(params, { providerOptions: { gateway: gatewayOptions } });
+    }
+  }
+  if (options?.samplingParams) {
+    Object.assign(params, options.samplingParams);
+  }
+  return params;
+}
+function resolveThinkingTokenBudgetField(compat) {
+  if (compat.thinkingTokenBudgetField)
+    return compat.thinkingTokenBudgetField;
+  if (compat.supportsThinkingTokenBudget)
+    return "thinking_token_budget";
+  return;
+}
+function resolveClampedThinkingBudget(model, options, params) {
+  if (!options?.reasoningEffort || !model.reasoning)
+    return;
+  const ceiling = params.max_tokens ?? params.max_completion_tokens ?? model.maxTokens;
+  const budget = clampThinkingBudgetToAnswerRoom2(thinkingBudgetForLevel2(options.reasoningEffort, options.thinkingBudgets), ceiling);
+  return budget > 0 ? budget : undefined;
+}
+function buildChatTemplateValues(model, options, values, thinkingBudget) {
+  const resolvedValues = {};
+  for (const [key, value] of Object.entries(values)) {
+    const resolved = resolveChatTemplateKwargValue(model, options, value, thinkingBudget);
+    if (resolved !== undefined) {
+      resolvedValues[key] = resolved;
+    }
+  }
+  return Object.keys(resolvedValues).length > 0 ? resolvedValues : undefined;
+}
+function resolveChatTemplateKwargValue(model, options, value, thinkingBudget) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const reasoningEffort = options?.reasoningEffort;
+  if (!reasoningEffort && value.omitWhenOff) {
+    return;
+  }
+  if (value.$var === "thinking.enabled") {
+    return !!reasoningEffort;
+  }
+  if (value.$var === "thinking.budget") {
+    return thinkingBudget;
+  }
+  const mappedValue = reasoningEffort ? model.thinkingLevelMap?.[reasoningEffort] : model.thinkingLevelMap?.off;
+  return mappedValue === undefined ? reasoningEffort : mappedValue ?? undefined;
+}
+
+export { buildParams2 };

package/dist/chunks/account-limits-cache-zpjmeyt0.js

@@ -0,0 +1,113 @@
+import {
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  ModelsError2
+} from "./account-limits-cache-7z9s8j16.js";
+
+// src/models-refresh.ts
+import { keyedSerial } from "@nyte-ai/schema/serial";
+class CatalogRefreshes2 {
+  generations = new Map;
+  controllers = new Map;
+  restorations = new Map;
+  publications = keyedSerial();
+  modelsStore;
+  catalog;
+  constructor(modelsStore, catalog) {
+    this.modelsStore = modelsStore;
+    this.catalog = catalog;
+  }
+  supersede(providerId) {
+    const generation = (this.generations.get(providerId) ?? 0) + 1;
+    this.generations.set(providerId, generation);
+    const previous = this.controllers.get(providerId);
+    if (previous) {
+      this.controllers.delete(providerId);
+      previous.abort();
+    }
+    return generation;
+  }
+  running() {
+    return this.controllers.keys();
+  }
+  publish(providerId, generation, signal, publication) {
+    const queued = this.publications.run(providerId, async () => {
+      if (signal.aborted || this.generations.get(providerId) !== generation)
+        return false;
+      if (publication.persist === null) {
+        await this.modelsStore.delete(providerId, { signal });
+      } else if (publication.persist !== undefined) {
+        await this.modelsStore.write(providerId, structuredClone(publication.persist), { signal });
+      }
+      if (signal.aborted || this.generations.get(providerId) !== generation)
+        return false;
+      publication.update?.();
+      return true;
+    });
+    return raceWithAbortSignal2(queued, signal);
+  }
+  async runPhase(provider, credential, allowNetwork, force, generation, signal) {
+    const stored = await this.modelsStore.read(provider.id, { signal });
+    await provider.refreshModels?.({
+      credential,
+      stored: stored ? structuredClone(stored) : undefined,
+      publish: (publication) => this.publish(provider.id, generation, signal, publication),
+      allowNetwork,
+      force: allowNetwork ? force : undefined,
+      catalog: this.catalog,
+      signal
+    });
+  }
+  async run(provider, allowNetwork, force, callerSignal, readAccounts, resolveCredential) {
+    const running = this.restorations.get(provider.id);
+    if (!allowNetwork && running !== undefined) {
+      await raceWithAbortSignal2(running, callerSignal).catch(() => {
+        return;
+      });
+      return;
+    }
+    const generation = this.supersede(provider.id);
+    const controller = new AbortController;
+    this.controllers.set(provider.id, controller);
+    const signal = AbortSignal.any([callerSignal, controller.signal]);
+    const restored = Promise.withResolvers();
+    this.restorations.set(provider.id, restored.promise);
+    const operation = (async () => {
+      let storedAccounts;
+      let credentialError;
+      try {
+        storedAccounts = allowNetwork ? await readAccounts(signal) : undefined;
+      } catch (error) {
+        credentialError = error;
+      }
+      await this.runPhase(provider, storedAccounts?.accounts.find((account) => account.id === storedAccounts.active)?.credential, false, undefined, generation, signal);
+      restored.resolve();
+      if (credentialError !== undefined)
+        throw credentialError;
+      if (!allowNetwork || signal.aborted)
+        return;
+      const credential = await resolveCredential(storedAccounts, signal);
+      await this.runPhase(provider, credential, true, force, generation, signal);
+    })();
+    try {
+      await raceWithAbortSignal2(operation, signal);
+      return;
+    } catch (error) {
+      if (signal.aborted)
+        return;
+      return error instanceof Error ? error : new ModelsError2("model_source", `Model refresh failed for ${provider.id}`, {
+        cause: error
+      });
+    } finally {
+      restored.resolve();
+      if (this.controllers.get(provider.id) === controller)
+        this.controllers.delete(provider.id);
+      if (this.restorations.get(provider.id) === restored.promise) {
+        this.restorations.delete(provider.id);
+      }
+    }
+  }
+}
+
+export { CatalogRefreshes2 };

package/dist/chunks/account-limits-cache-zqdb4yh4.js

@@ -0,0 +1,8 @@
+import {
+  lazyApi2
+} from "./account-limits-cache-90c9c2eb.js";
+
+// src/api/anthropic-messages.lazy.ts
+var anthropicMessagesApi2 = () => lazyApi2(() => import("../src/api/anthropic-messages.js"));
+
+export { anthropicMessagesApi2 };

package/dist/src/account-limits-cache.d.ts

@@ -0,0 +1,16 @@
+import type { AccountLimits, AccountLimitsResult } from "./types.ts";
+/** A request's account observations cannot outlive the credential selection it started with. */
+interface AccountLimitsScope {
+    observe(accountId: string | undefined, limits: AccountLimits): void;
+    fetch(accountId: string | undefined, load: (signal: AbortSignal) => Promise<AccountLimits | undefined>, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<AccountLimitsResult>;
+}
+/** Owns account quota freshness, shared requests, and credential lifecycle invalidation. */
+export declare class AccountLimitsCache {
+    private readonly providers;
+    get(providerId: string, accountId?: string | null): AccountLimits | undefined;
+    invalidate(providerId: string): void;
+    scope(providerId: string): AccountLimitsScope;
+}
+export {};

package/dist/src/account-limits-cache.js

@@ -0,0 +1,7 @@
+import {
+  AccountLimitsCache2
+} from "../chunks/account-limits-cache-hemxtapd.js";
+import"../chunks/account-limits-cache-j2bt392s.js";
+export {
+  AccountLimitsCache2 as AccountLimitsCache
+};

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

@@ -0,0 +1,25 @@
+/**
+ * The Anthropic SDK client for a request: compat defaults, beta headers,
+ * authentication (API key, OAuth, Copilot, OIDC federation) and header merging.
+ */
+import Anthropic, { type ClientOptions } from "@anthropic-ai/sdk";
+import type { AnthropicMessagesCompat, Model, ProviderEnv, ProviderHeaders, TranscriptContext } from "../types.ts";
+export declare const FAST_MODE_BETA = "fast-mode-2026-02-01";
+export declare const MID_CONVERSATION_TOOL_CHANGES_BETA = "mid-conversation-tool-changes-2026-07-01";
+export declare function shouldUseServerSideFallbackBeta(model: Model<"anthropic-messages">): boolean;
+export declare function getAnthropicCompat(model: Model<"anthropic-messages">): Required<Omit<AnthropicMessagesCompat, "forceAdaptiveThinking" | "allowedFallbackModels">>;
+export declare function mergeAnthropicHeaders(...headerSources: (ProviderHeaders | undefined)[]): ProviderHeaders;
+export declare function appendAnthropicBeta(headers: ProviderHeaders, beta: string | undefined): ProviderHeaders;
+export declare function assertRequestAuth(provider: string, apiKey: string | undefined, headers: ProviderHeaders | undefined): void;
+type AnthropicFederationConfig = NonNullable<ClientOptions["config"]>;
+export declare function getAnthropicFederation(model: Model<"anthropic-messages">, apiKey: string | undefined, headers: ProviderHeaders | undefined, env: ProviderEnv | undefined): AnthropicFederationConfig | undefined;
+/**
+ * The SDK client and whether it signs in as Claude Code. Adaptive thinking models have
+ * interleaved thinking built in, so they skip the interleaved-thinking beta header.
+ */
+export declare function createClient(model: Model<"anthropic-messages">, apiKey: string | undefined, interleavedThinking: boolean, useFineGrainedToolStreamingBeta: boolean, useServerSideFallbackBeta: boolean, useFastModeBeta: boolean, useMidConversationToolChangesBeta: boolean, optionsHeaders?: ProviderHeaders, fetch?: typeof globalThis.fetch, dynamicHeaders?: ProviderHeaders, sessionId?: string, federation?: AnthropicFederationConfig): {
+    client: Anthropic;
+    isOAuthToken: boolean;
+};
+export declare function shouldUseFineGrainedToolStreamingBeta(model: Model<"anthropic-messages">, context: TranscriptContext): boolean;
+export {};

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

@@ -0,0 +1,30 @@
+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-ks1sjym9.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-gknnm1kv.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-hyzn1jmk.js";
+import"../../chunks/account-limits-cache-b23sbrke.js";
+export {
+  FAST_MODE_BETA2 as FAST_MODE_BETA,
+  MID_CONVERSATION_TOOL_CHANGES_BETA2 as MID_CONVERSATION_TOOL_CHANGES_BETA,
+  appendAnthropicBeta2 as appendAnthropicBeta,
+  assertRequestAuth2 as assertRequestAuth,
+  createClient2 as createClient,
+  getAnthropicCompat2 as getAnthropicCompat,
+  getAnthropicFederation2 as getAnthropicFederation,
+  mergeAnthropicHeaders2 as mergeAnthropicHeaders,
+  shouldUseFineGrainedToolStreamingBeta2 as shouldUseFineGrainedToolStreamingBeta,
+  shouldUseServerSideFallbackBeta2 as shouldUseServerSideFallbackBeta
+};

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

@@ -0,0 +1,17 @@
+import type { BetaTool, BetaCacheControlEphemeral, BetaMessageParam } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
+import type { Message, Tool } from "../types.ts";
+export declare function normalizeToolCallId(id: string): string;
+/**
+ * The transcript as Anthropic messages.
+ *
+ * - Anthropic requires `tool_result` immediately after `tool_use`, so system updates are held
+ *   until the next assistant message or the end of the transcript.
+ * - A thinking block whose signature is missing or empty, e.g. from an aborted stream, becomes
+ *   plain text; models marked `allowEmptySignature` emit and accept empty signatures, so they
+ *   keep the block.
+ * - Consecutive tool results go into one user message, which the z.ai Anthropic endpoint needs;
+ *   content displaced by tool references follows every `tool_result` block.
+ * - The last user or system message carries `cache_control`, caching the conversation history.
+ */
+export declare function convertMessages(transformedMessages: Message[], isOAuthToken: boolean, cacheControl?: BetaCacheControlEphemeral, allowEmptySignature?: boolean, deferredToolNames?: ReadonlySet<string>, normalizeToolName?: (name: string) => string, nativeToolChanges?: boolean): BetaMessageParam[];
+export declare function convertTools(tools: Tool[], isOAuthToken: boolean, supportsEagerToolInputStreaming: boolean, supportsStrictTools: boolean, cacheControl?: BetaCacheControlEphemeral, deferLoading?: boolean): BetaTool[];

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

@@ -0,0 +1,14 @@
+import {
+  normalizeToolCallId2,
+  convertMessages3,
+  convertTools3
+} from "../../chunks/account-limits-cache-4b8ckwqw.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-ks1sjym9.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+export {
+  convertMessages3 as convertMessages,
+  convertTools3 as convertTools,
+  normalizeToolCallId2 as normalizeToolCallId
+};