@nyte-ai/ai 0.0.0-stage → 0.0.19

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
+};

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

@@ -0,0 +1,101 @@
+import { Type, type Static } from "typebox";
+export declare const AnthropicEventSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"message_start">;
+    message: Type.TObject<{
+        id: Type.TString;
+        model: Type.TString;
+        usage: Type.TObject<{
+            input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            output_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            cache_read_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            cache_creation_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            cache_creation: Type.TOptional<Type.TUnion<[Type.TObject<{
+                ephemeral_1h_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            }>, Type.TNull]>>;
+            output_tokens_details: Type.TOptional<Type.TUnion<[Type.TObject<{
+                thinking_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+            }>, Type.TNull]>>;
+            speed: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        }>;
+    }>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"message_delta">;
+    delta: Type.TObject<{
+        stop_reason: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        stop_details: Type.TOptional<Type.TUnion<[Type.TObject<{
+            explanation: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        }>, Type.TNull]>>;
+    }>;
+    usage: Type.TOptional<Type.TUnion<[Type.TObject<{
+        input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        output_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        cache_read_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        cache_creation_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        cache_creation: Type.TOptional<Type.TUnion<[Type.TObject<{
+            ephemeral_1h_input_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        }>, Type.TNull]>>;
+        output_tokens_details: Type.TOptional<Type.TUnion<[Type.TObject<{
+            thinking_tokens: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+        }>, Type.TNull]>>;
+        speed: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>, Type.TNull]>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"message_stop">;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_start">;
+    index: Type.TInteger;
+    content_block: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"text">;
+        text: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"thinking">;
+        thinking: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        signature: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"redacted_thinking">;
+        data: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"tool_use">;
+        id: Type.TString;
+        name: Type.TString;
+        input: Type.TOptional<Type.TUnion<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TNull]>>;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_delta">;
+    index: Type.TInteger;
+    delta: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"text_delta">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"thinking_delta">;
+        thinking: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"input_json_delta">;
+        partial_json: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"signature_delta">;
+        signature: Type.TString;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_stop">;
+    index: Type.TInteger;
+}>]>;
+export type AnthropicEvent = Static<typeof AnthropicEventSchema>;
+export declare const AnthropicEventTypeSchema: Type.TUnion<[Type.TLiteral<"message_start">, Type.TLiteral<"message_delta">, Type.TLiteral<"message_stop">, Type.TLiteral<"content_block_start">, Type.TLiteral<"content_block_delta">, Type.TLiteral<"content_block_stop">]>;
+/**
+ * Unknown block variants are forward-compatible. Malformed *known* variants must
+ * not fall through this alternative, so its exclusions derive from the schemas above.
+ */
+export declare const IgnoredAnthropicEventSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"content_block_start">;
+    index: Type.TInteger;
+    content_block: Type.TObject<{
+        type: Type.TString;
+    }>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"content_block_delta">;
+    index: Type.TInteger;
+    delta: Type.TObject<{
+        type: Type.TString;
+    }>;
+}>]>;

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

@@ -0,0 +1,11 @@
+import {
+  AnthropicEventSchema2,
+  AnthropicEventTypeSchema2,
+  IgnoredAnthropicEventSchema2
+} from "../../chunks/account-limits-cache-3ykqmnj5.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+export {
+  AnthropicEventSchema2 as AnthropicEventSchema,
+  AnthropicEventTypeSchema2 as AnthropicEventTypeSchema,
+  IgnoredAnthropicEventSchema2 as IgnoredAnthropicEventSchema
+};