@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/internal/openai.d.mts

@@ -0,0 +1,244 @@
+import { E as Model, F as SimpleStreamOptions, I as StopReason, O as OpenAICompletionsCompat, R as StreamFunction, u as Context, z as StreamOptions } from "../types-DRgdPqaZ.mjs";
+import OpenAI from "openai";
+import { TSchema } from "typebox";
+import { ChatCompletionMessageParam } from "openai/resources/chat/completions.js";
+import { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+
+//#region packages/ai/src/providers/agent-tools-parameter-schema.d.ts
+/**
+ * Narrow structural view of the host's model compat config. packages/ai must stay
+ * config-agnostic, so only tool-schema-relevant fields are modeled here; the host's
+ * ModelCompatConfig remains structurally assignable.
+ */
+type ToolSchemaModelCompat = {
+  toolSchemaProfile?: string;
+  unsupportedToolSchemaKeywords?: string[];
+  omitEmptyArrayItems?: boolean;
+};
+/** Extracts the compat record whether callers pass a model (`{ compat }`) or the compat itself. */
+declare function extractToolSchemaModelCompat(modelOrCompat: {
+  compat?: unknown;
+} | ToolSchemaModelCompat | undefined): ToolSchemaModelCompat | undefined;
+/** JSON Schema keywords this model/provider rejects in tool schemas. */
+declare function resolveUnsupportedToolSchemaKeywords(modelOrCompat: {
+  compat?: unknown;
+} | ToolSchemaModelCompat | undefined): ReadonlySet<string>;
+/** Whether empty `items: {}` on array schemas must be omitted for this model/provider. */
+declare function shouldOmitEmptyArrayItems(modelOrCompat: {
+  compat?: unknown;
+} | ToolSchemaModelCompat | undefined): boolean;
+type ToolParameterSchemaOptions = {
+  modelProvider?: string;
+  modelId?: string;
+  modelCompat?: ToolSchemaModelCompat;
+};
+/** Return a provider-compatible JSON schema for a model-facing tool. */
+declare function normalizeToolParameterSchema(schema: unknown, options?: ToolParameterSchemaOptions): TSchema;
+//#endregion
+//#region packages/ai/src/providers/azure-deployment-map.d.ts
+/** Parses AZURE_OPENAI_DEPLOYMENT_MAP-style model=deployment entries. */
+declare function parseAzureDeploymentNameMap(value: string | undefined): Map<string, string>;
+/** Resolves the Azure deployment name for a model id, falling back to the model id. */
+declare function resolveAzureDeploymentNameFromMap(params: {
+  modelId: string;
+  deploymentMap?: string;
+}): string;
+//#endregion
+//#region packages/ai/src/providers/azure-openai-responses-client-compat.d.ts
+declare function isTraditionalAzureOpenAIHost(hostname: string): boolean;
+declare function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl: string): boolean;
+//#endregion
+//#region packages/ai/src/providers/clean-for-gemini.d.ts
+declare const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS: Set<string>;
+declare function cleanSchemaForGemini(schema: unknown): TSchema;
+//#endregion
+//#region packages/ai/src/providers/openai-tool-projection.d.ts
+type OpenAIToolDescriptor = {
+  readonly name?: unknown;
+  readonly description?: unknown;
+  readonly parameters: unknown;
+};
+type OpenAIProjectedTool = {
+  readonly toolIndex: number;
+  readonly name: string;
+  readonly description?: string;
+  readonly parameters: Record<string, unknown>;
+};
+type OpenAIToolProjectionDiagnostic = {
+  readonly toolIndex: number;
+  readonly toolName?: string;
+  readonly violations: readonly string[];
+};
+type OpenAIToolProjection = {
+  readonly inputToolCount: number;
+  readonly tools: readonly OpenAIProjectedTool[];
+  readonly diagnostics: readonly OpenAIToolProjectionDiagnostic[];
+};
+type OpenAIResponsesToolChoice = ResponseCreateParamsStreaming["tool_choice"];
+type OpenAICompletionsSdkToolChoice = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming["tool_choice"];
+type OpenAICompletionsToolChoice = Exclude<OpenAICompletionsSdkToolChoice, {
+  type: "custom";
+}>;
+/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
+declare function projectOpenAITools(tools: readonly OpenAIToolDescriptor[]): OpenAIToolProjection;
+/** Keeps Responses tool choices aligned with surviving function schemas. */
+declare function reconcileOpenAIResponsesToolChoice(choice: OpenAIResponsesToolChoice, projection: OpenAIToolProjection): OpenAIResponsesToolChoice | undefined;
+/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
+declare function reconcileOpenAICompletionsToolChoice(choice: OpenAICompletionsSdkToolChoice, projection: OpenAIToolProjection): OpenAICompletionsSdkToolChoice | undefined;
+//#endregion
+//#region packages/ai/src/providers/openai-completions.d.ts
+interface OpenAICompletionsOptions extends StreamOptions {
+  toolChoice?: OpenAICompletionsToolChoice;
+  reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+}
+type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat"> & {
+  cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+};
+declare const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
+declare const streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions>;
+declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompletionsCompat, options?: {
+  cacheOptOutIndexes?: Set<number>;
+  preserveSystemPromptCacheBoundary?: boolean;
+}): ChatCompletionMessageParam[];
+//#endregion
+//#region packages/ai/src/providers/openai-prompt-cache.d.ts
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+declare function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined;
+//#endregion
+//#region packages/ai/src/providers/openai-reasoning-effort.d.ts
+type OpenAIReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+type OpenAIApiReasoningEffort = OpenAIReasoningEffort | (string & {});
+type OpenAIReasoningModel = {
+  provider?: unknown;
+  id?: unknown;
+  name?: unknown;
+  api?: unknown;
+  baseUrl?: unknown;
+  compat?: unknown;
+};
+/** Return whether a model is the GPT-5.4 mini family. */
+declare function isOpenAIGpt54MiniModel(model: OpenAIReasoningModel): boolean;
+/** Return whether a model is the GPT-5.5 family. */
+declare function isOpenAIGpt55Model(model: OpenAIReasoningModel): boolean;
+/** Return whether a model is the GPT-5.6 family. */
+declare function isOpenAIGpt56Model(model: OpenAIReasoningModel): boolean;
+/** Normalize user-facing reasoning effort names to API effort names. */
+declare function normalizeOpenAIReasoningEffort(effort: string): string;
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+declare function resolveOpenAISupportedReasoningEfforts(model: OpenAIReasoningModel): readonly OpenAIApiReasoningEffort[];
+/** Return whether a model accepts a requested reasoning effort. */
+declare function supportsOpenAIReasoningEffort(model: OpenAIReasoningModel, effort: string): boolean;
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+declare function resolveOpenAIReasoningEffortForModel(params: {
+  model: OpenAIReasoningModel;
+  effort: string;
+  fallbackMap?: Record<string, string>;
+}): OpenAIApiReasoningEffort | undefined;
+//#endregion
+//#region packages/ai/src/providers/openai-responses.d.ts
+interface OpenAIResponsesOptions extends StreamOptions {
+  reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+  reasoningSummary?: "auto" | "detailed" | "concise" | null;
+  replayResponsesItemIds?: boolean;
+  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+}
+/**
+ * Generate function for OpenAI Responses API
+ */
+declare const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
+declare const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions>;
+//#endregion
+//#region packages/ai/src/providers/openai-responses-stream-compat.d.ts
+declare const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
+declare const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
+declare const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
+declare const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
+type ResponsesTextContentPartType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE | typeof AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE;
+type ResponsesTextDeltaEventType = typeof OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE | typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+type AzureResponsesTextContentPart = {
+  type: typeof AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE;
+  text: string;
+};
+type AzureResponsesTextDeltaEvent = {
+  type: typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+  delta: string;
+};
+declare function isResponsesTextContentPartType(type: unknown): type is ResponsesTextContentPartType;
+declare function isResponsesTextDeltaEventType(type: unknown): type is ResponsesTextDeltaEventType;
+declare function isAzureResponsesTextDeltaEventType(type: unknown): type is typeof AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+declare function isAzureResponsesTextDeltaEvent(event: {
+  type?: unknown;
+  delta?: unknown;
+}): event is AzureResponsesTextDeltaEvent;
+type ResponsesMessageSnapshotCollapse = {
+  kind: "extend";
+  text: string;
+} | {
+  kind: "keep";
+};
+declare function resolveResponsesMessageSnapshotCollapse(params: {
+  prior: {
+    text: string;
+    phase: string | undefined;
+  } | null;
+  nextText: string;
+  nextPhase: string | undefined;
+}): ResponsesMessageSnapshotCollapse;
+//#endregion
+//#region packages/ai/src/providers/openai-stop-reason.d.ts
+type OpenAIStopReasonResult = {
+  stopReason: StopReason;
+  errorMessage?: string;
+};
+declare function mapOpenAIStopReason(reason: string | null, options?: {
+  allowSingularToolCall?: boolean;
+}): OpenAIStopReasonResult;
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema.d.ts
+/**
+ * OpenAI strict-tool-schema normalization and diagnostics.
+ *
+ * Strict schemas need all object properties required and `additionalProperties: false`; model
+ * compatibility settings can also remove unsupported schema constructs before strict checks run.
+ */
+type ToolSchemaCompatInput = {
+  unsupportedToolSchemaKeywords?: unknown;
+  omitEmptyArrayItems?: unknown;
+};
+declare function clearOpenAIToolSchemaCacheForTest(): void;
+/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
+declare function normalizeStrictOpenAIJsonSchema(schema: unknown, modelCompat?: ToolSchemaCompatInput | null): unknown;
+/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
+declare function normalizeOpenAIStrictToolParameters<T>(schema: T, strict: boolean, modelCompat?: ToolSchemaCompatInput | null): T;
+/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
+declare function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean;
+type OpenAIStrictToolSchemaDiagnostic = {
+  toolIndex: number;
+  toolName?: string;
+  violations: string[];
+};
+/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
+declare function findOpenAIStrictToolProjectionDiagnostics(projection: OpenAIToolProjection): OpenAIStrictToolSchemaDiagnostic[];
+/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
+declare function resolveOpenAIProjectedToolsStrictToolFlag(projection: OpenAIToolProjection, strict: boolean | null | undefined): boolean | undefined;
+//#endregion
+//#region packages/ai/src/providers/schema-keyword-strip.d.ts
+/** Recursively remove schema keywords unsupported by a target provider/tool surface. */
+declare function stripUnsupportedSchemaKeywords(schema: unknown, unsupportedKeywords: ReadonlySet<string>): unknown;
+//#endregion
+//#region packages/ai/src/providers/tool-schema-json-projection.d.ts
+/** JSON-safe schema value used when projecting runtime tool parameters. */
+type RuntimeToolInputSchemaJson = null | boolean | number | string | RuntimeToolInputSchemaJson[] | {
+  [key: string]: RuntimeToolInputSchemaJson;
+};
+/** Projected runtime tool schema plus validation violations. */
+type RuntimeToolInputSchemaProjection = {
+  readonly schema: RuntimeToolInputSchemaJson;
+  readonly violations: readonly string[];
+};
+/** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
+declare function projectRuntimeToolInputSchema(schema: unknown, path?: string): RuntimeToolInputSchemaProjection;
+//#endregion
+export { AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE, AzureResponsesTextContentPart, AzureResponsesTextDeltaEvent, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE, OpenAIApiReasoningEffort, OpenAICompletionsOptions, OpenAICompletionsToolChoice, OpenAIReasoningEffort, OpenAIResponsesOptions, OpenAIStopReasonResult, OpenAIToolProjection, ResponsesMessageSnapshotCollapse, ResponsesTextContentPartType, ResponsesTextDeltaEventType, RuntimeToolInputSchemaJson, RuntimeToolInputSchemaProjection, ToolParameterSchemaOptions, ToolSchemaModelCompat, clampOpenAIPromptCacheKey, cleanSchemaForGemini, clearOpenAIToolSchemaCacheForTest, convertMessages, extractToolSchemaModelCompat, findOpenAIStrictToolProjectionDiagnostics, isAzureResponsesTextDeltaEvent, isAzureResponsesTextDeltaEventType, isOpenAICompatibleAzureResponsesBaseUrl, isOpenAIGpt54MiniModel, isOpenAIGpt55Model, isOpenAIGpt56Model, isResponsesTextContentPartType, isResponsesTextDeltaEventType, isStrictOpenAIJsonSchemaCompatible, isTraditionalAzureOpenAIHost, mapOpenAIStopReason, normalizeOpenAIReasoningEffort, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, normalizeToolParameterSchema, parseAzureDeploymentNameMap, projectOpenAITools, projectRuntimeToolInputSchema, reconcileOpenAICompletionsToolChoice, reconcileOpenAIResponsesToolChoice, resolveAzureDeploymentNameFromMap, resolveOpenAIProjectedToolsStrictToolFlag, resolveOpenAIReasoningEffortForModel, resolveOpenAISupportedReasoningEfforts, resolveResponsesMessageSnapshotCollapse, resolveUnsupportedToolSchemaKeywords, shouldOmitEmptyArrayItems, streamOpenAICompletions, streamOpenAIResponses, streamSimpleOpenAICompletions, streamSimpleOpenAIResponses, stripUnsupportedSchemaKeywords, supportsOpenAIReasoningEffort };

package/dist/internal/openai.mjs

@@ -0,0 +1,7 @@
+import { t as projectRuntimeToolInputSchema } from "../tool-schema-json-projection-BXtBc_mD.mjs";
+import { A as extractToolSchemaModelCompat, C as isOpenAIGpt54MiniModel, D as resolveOpenAIReasoningEffortForModel, E as normalizeOpenAIReasoningEffort, F as GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, I as cleanSchemaForGemini, M as resolveUnsupportedToolSchemaKeywords, N as shouldOmitEmptyArrayItems, O as resolveOpenAISupportedReasoningEfforts, P as stripUnsupportedSchemaKeywords, S as resolveResponsesMessageSnapshotCollapse, T as isOpenAIGpt56Model, _ as OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE, b as isResponsesTextContentPartType, c as clearOpenAIToolSchemaCacheForTest, d as normalizeOpenAIStrictToolParameters, f as normalizeStrictOpenAIJsonSchema, g as OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE, h as AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE, j as normalizeToolParameterSchema, k as supportsOpenAIReasoningEffort, l as findOpenAIStrictToolProjectionDiagnostics, m as AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE, p as resolveOpenAIProjectedToolsStrictToolFlag, u as isStrictOpenAIJsonSchemaCompatible, v as isAzureResponsesTextDeltaEvent, w as isOpenAIGpt55Model, x as isResponsesTextDeltaEventType, y as isAzureResponsesTextDeltaEventType } from "../openai-responses-shared-sj2YUPYc.mjs";
+import { i as resolveAzureDeploymentNameFromMap, n as isTraditionalAzureOpenAIHost, r as parseAzureDeploymentNameMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "../azure-openai-responses-client-compat-a_O_GVQV.mjs";
+import { a as clampOpenAIPromptCacheKey, i as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, n as reconcileOpenAICompletionsToolChoice, r as reconcileOpenAIResponsesToolChoice, t as projectOpenAITools } from "../openai-tool-projection-BknoV11q.mjs";
+import { a as mapOpenAIStopReason, i as streamSimpleOpenAICompletions, r as streamOpenAICompletions, t as convertMessages } from "../openai-completions-B9QLIq2U.mjs";
+import { n as streamOpenAIResponses, r as streamSimpleOpenAIResponses } from "../openai-responses-B6LylGxM.mjs";
+export { AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE, clampOpenAIPromptCacheKey, cleanSchemaForGemini, clearOpenAIToolSchemaCacheForTest, convertMessages, extractToolSchemaModelCompat, findOpenAIStrictToolProjectionDiagnostics, isAzureResponsesTextDeltaEvent, isAzureResponsesTextDeltaEventType, isOpenAICompatibleAzureResponsesBaseUrl, isOpenAIGpt54MiniModel, isOpenAIGpt55Model, isOpenAIGpt56Model, isResponsesTextContentPartType, isResponsesTextDeltaEventType, isStrictOpenAIJsonSchemaCompatible, isTraditionalAzureOpenAIHost, mapOpenAIStopReason, normalizeOpenAIReasoningEffort, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, normalizeToolParameterSchema, parseAzureDeploymentNameMap, projectOpenAITools, projectRuntimeToolInputSchema, reconcileOpenAICompletionsToolChoice, reconcileOpenAIResponsesToolChoice, resolveAzureDeploymentNameFromMap, resolveOpenAIProjectedToolsStrictToolFlag, resolveOpenAIReasoningEffortForModel, resolveOpenAISupportedReasoningEfforts, resolveResponsesMessageSnapshotCollapse, resolveUnsupportedToolSchemaKeywords, shouldOmitEmptyArrayItems, streamOpenAICompletions, streamOpenAIResponses, streamSimpleOpenAICompletions, streamSimpleOpenAIResponses, stripUnsupportedSchemaKeywords, supportsOpenAIReasoningEffort };

package/dist/internal/runtime.d.mts

@@ -0,0 +1,245 @@
+import { D as ModelThinkingLevel, E as Model, F as SimpleStreamOptions, P as ProviderStreamOptions, X as Usage, i as AssistantMessage, n as Api, o as AssistantMessageEventStreamContract, u as Context, z as StreamOptions } from "../types-DRgdPqaZ.mjs";
+import { a as RegisteredApiProvider, t as ApiProvider } from "../api-registry-BXYnCOIR.mjs";
+import { t as sanitizeSurrogates } from "../sanitize-unicode-BZiVbGwK.mjs";
+
+//#region packages/ai/src/internal/default-runtime.d.ts
+declare const defaultApiRegistry: {
+  registerApiProvider: <TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string) => void;
+  getApiProvider: (api: Api) => RegisteredApiProvider | undefined;
+  getApiProviders: () => RegisteredApiProvider[];
+  unregisterApiProviders: (sourceId: string) => void;
+  clearApiProviders: () => void;
+};
+declare const defaultLlmRuntime: {
+  registry: {
+    registerApiProvider: <TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string) => void;
+    getApiProvider: (api: Api) => RegisteredApiProvider | undefined;
+    getApiProviders: () => RegisteredApiProvider[];
+    unregisterApiProviders: (sourceId: string) => void;
+    clearApiProviders: () => void;
+  };
+  stream: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => AssistantMessageEventStreamContract;
+  complete: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => Promise<AssistantMessage>;
+  streamSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStreamContract;
+  completeSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => Promise<AssistantMessage>;
+};
+declare const registerApiProvider: <TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string) => void, getApiProvider: (api: Api) => RegisteredApiProvider | undefined, getApiProviders: () => RegisteredApiProvider[], unregisterApiProviders: (sourceId: string) => void, clearApiProviders: () => void;
+declare const stream: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => AssistantMessageEventStreamContract, complete: <TApi extends Api>(model: Model<TApi>, context: Context, options?: ProviderStreamOptions) => Promise<AssistantMessage>, streamSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStreamContract, completeSimple: <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => Promise<AssistantMessage>;
+//#endregion
+//#region packages/ai/src/env-api-keys.d.ts
+/**
+ * Find configured environment variables that can provide an API key for a provider.
+ *
+ * This only reports actual API key variables. It intentionally excludes ambient
+ * credential sources such as AWS profiles, AWS IAM credentials, and Google
+ * Application Default Credentials.
+ */
+declare function findEnvKeys(provider: string): string[] | undefined;
+/**
+ * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+ *
+ * Will not return API keys for providers that require OAuth tokens.
+ */
+declare function getEnvApiKey(provider: string): string | undefined;
+//#endregion
+//#region packages/ai/src/model-utils.d.ts
+/** Calculates and stores model cost fields from token usage and per-million pricing. */
+declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+/** Replaces the catalog estimate when the provider reports an authoritative billed total. */
+declare function applyProviderReportedUsageCost(usage: Usage, reportedCost: unknown): void;
+/** Returns thinking levels exposed by a reasoning-capable model. */
+declare function getSupportedThinkingLevels<TApi extends Api>(model: Model<TApi>): ModelThinkingLevel[];
+/** Clamps a requested thinking level to the closest supported level for a model. */
+declare function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: ModelThinkingLevel): ModelThinkingLevel;
+/** Compares model identity by provider and id. */
+declare function modelsAreEqual<TApi extends Api>(a: Model<TApi> | null | undefined, b: Model<TApi> | null | undefined): boolean;
+//#endregion
+//#region packages/ai/src/session-resources.d.ts
+/** Cleanup callback for resources tied to an LLM session or all sessions. */
+type SessionResourceCleanup = (sessionId?: string) => void;
+/** Registers a session-resource cleanup hook and returns an unregister function. */
+declare function registerSessionResourceCleanup(cleanup: SessionResourceCleanup): () => void;
+/** Runs all registered cleanup hooks, aggregating failures after every hook has run. */
+declare function cleanupSessionResources(sessionId?: string): void;
+//#endregion
+//#region packages/ai/src/utils/deferred-event-buffer.d.ts
+type EventSink<T> = {
+  push(event: T): void;
+};
+declare function createDeferredEventBuffer<T>(sink: EventSink<T>, onBufferedEvent?: () => void): {
+  push(event: T): void;
+  flush(): void;
+  discard(): void;
+};
+//#endregion
+//#region packages/ai/src/utils/hash.d.ts
+/** Fast deterministic hash to shorten long strings */
+declare function shortHash(str: string): string;
+//#endregion
+//#region packages/ai/src/utils/headers.d.ts
+/** Converts a Headers object to a plain record for provider request handling. */
+declare function headersToRecord(headers: Headers): Record<string, string>;
+//#endregion
+//#region packages/ai/src/utils/json-parse.d.ts
+/**
+ * Repairs malformed JSON string literals by:
+ * - escaping raw control characters inside strings
+ * - doubling backslashes before invalid escape characters
+ */
+declare function repairJson(json: string): string;
+declare function parseJsonWithRepair(json: string): unknown;
+/**
+ * Attempts to parse potentially incomplete JSON during streaming.
+ * Always returns a valid object, even if the JSON is incomplete.
+ *
+ * @param partialJson The partial JSON string from streaming
+ * @returns Parsed object or empty object if parsing fails
+ */
+declare function parseStreamingJson(partialJson: string | undefined): Record<string, unknown>;
+//#endregion
+//#region packages/ai/src/utils/llm-request-activity.d.ts
+declare function notifyLlmRequestActivity(signal: AbortSignal | undefined): void;
+declare function onLlmRequestActivity(signal: AbortSignal, listener: () => void): () => void;
+//#endregion
+//#region packages/ai/src/utils/oauth/openai-chatgpt-jwt.d.ts
+declare const OPENAI_CODEX_AUTH_CLAIM = "https://api.openai.com/auth";
+type OpenAICodexJwtPayload = {
+  [OPENAI_CODEX_AUTH_CLAIM]?: {
+    chatgpt_account_id?: unknown;
+  };
+  [key: string]: unknown;
+};
+declare function decodeOpenAICodexJwtPayload(token: string): OpenAICodexJwtPayload | null;
+declare function resolveOpenAICodexAccountId(token: string): string | null;
+//#endregion
+//#region packages/ai/src/utils/overflow.d.ts
+/** Detects DS4-style raw token-count context overflow errors. */
+declare function isConfiguredContextSizeOverflowError(errorMessage: string): boolean;
+/**
+ * Check if an assistant message represents a context overflow error.
+ *
+ * This handles two cases:
+ * 1. Error-based overflow: Most providers return stopReason "error" with a
+ *    specific error message pattern.
+ * 2. Silent overflow: Some providers accept overflow requests and return
+ *    successfully. For these, we check if usage.input exceeds the context window.
+ *
+ * ## Reliability by Provider
+ *
+ * **Reliable detection (returns error with detectable message):**
+ * - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
+ * - OpenAI (Completions & Responses): "exceeds the context window" or "exceeds the model's maximum context length of X tokens"
+ * - Google Gemini: "input token count exceeds the maximum"
+ * - xAI (Grok): "maximum prompt length is X but request contains Y"
+ * - Groq: "reduce the length of the messages"
+ * - Cerebras: 400/413 status code (no body)
+ * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+ * - OpenRouter (all backends): "maximum context length is X tokens"
+ * - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+ * - llama.cpp: "exceeds the available context size"
+ * - LM Studio: "greater than the context length"
+ * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
+ *
+ * **Unreliable detection:**
+ * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
+ *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+ * - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
+ *   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
+ * - Ollama: May truncate input silently for some setups, but may also return explicit
+ *   overflow errors that match the patterns above. Silent truncation still cannot be
+ *   detected here because we do not know the expected token count.
+ *
+ * ## Custom Providers
+ *
+ * If you've added custom models via settings.json, this function may not detect
+ * overflow errors from those providers. To add support:
+ *
+ * 1. Send a request that exceeds the model's context window
+ * 2. Check the errorMessage in the response
+ * 3. Create a regex pattern that matches the error
+ * 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
+ *    check the errorMessage yourself before calling this function
+ *
+ * @param message - The assistant message to check
+ * @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
+ * @returns true if the message indicates a context overflow
+ */
+declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+//#endregion
+//#region packages/ai/src/utils/reasoning-tag-text-partitioner.d.ts
+type ReasoningTagTextDelta = {
+  kind: "text";
+  text: string;
+} | {
+  kind: "thinking";
+  text: string;
+};
+interface ReasoningTagTextPartitioner {
+  markStrict(): void;
+  push(chunk: string): ReasoningTagTextDelta[];
+  pushVisible(chunk: string): ReasoningTagTextDelta[];
+  flush(): ReasoningTagTextDelta[];
+  hasPending(): boolean;
+  isInsideReasoning(): boolean;
+}
+declare function createReasoningTagTextPartitioner(): ReasoningTagTextPartitioner;
+//#endregion
+//#region packages/ai/src/utils/stream-first-event-timeout.d.ts
+type StreamStage = "responses" | "completions";
+type FirstStreamEventTimeoutContext = {
+  provider?: string;
+  api?: string;
+  model?: string;
+  timeoutMs: number;
+  stage?: StreamStage;
+  hint?: string;
+  abort?: (reason: Error) => void;
+  onTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventInternalOptions = {
+  firstEventTimeoutMs?: number;
+  abortFirstEventStream?: (reason: Error) => void;
+  onFirstEventTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventAbortController = {
+  signal: AbortSignal;
+  abort: (reason: Error) => void;
+  dispose: () => void;
+};
+declare function getFirstStreamEventTimeoutMs(options: unknown): number | undefined;
+declare function getFirstStreamEventTimeoutHandler(options: unknown): ((reason: Error) => void) | undefined;
+declare function createFirstStreamEventTimeoutError(context: FirstStreamEventTimeoutContext): Error;
+declare function createFirstStreamEventAbortController(parentSignal?: AbortSignal): FirstStreamEventAbortController;
+declare function withFirstStreamEventTimeout<T>(stream: AsyncIterable<T>, context: FirstStreamEventTimeoutContext): AsyncIterable<T>;
+//#endregion
+//#region packages/ai/src/utils/streaming-byte-guard.d.ts
+/**
+ * Bounded SSE / NDJSON stream reader guard.
+ *
+ * Wraps a `ReadableStreamDefaultReader<Uint8Array>` so the caller's existing
+ * chunk-by-chunk parsing logic is unchanged, but accumulated bytes are tracked
+ * against a hard cap. On overflow the underlying reader is cancelled and a
+ * canonical error is thrown. Mirrors the `readResponseWithLimit` / bounded
+ * JSON response pattern (see `src/agents/provider-http-errors.ts`).
+ *
+ * Internal helper for now. If extensions need it, promote to a plugin-SDK
+ * subpath in a separate, dedicated PR with full SDK metadata sync.
+ */
+type SseStreamOverflow = {
+  size: number;
+  maxBytes: number;
+};
+type ReadSseStreamWithLimitOptions = {
+  maxBytes: number;
+  onOverflow?: (params: SseStreamOverflow) => Error;
+};
+type SseByteGuard = {
+  read(): Promise<ReadableStreamReadResult<Uint8Array>>;
+  cancel(reason?: unknown): Promise<void>;
+  totalBytes(): number;
+  overflowed(): boolean;
+  cancelled(): boolean;
+};
+declare function createSseByteGuard(reader: ReadableStreamDefaultReader<Uint8Array>, opts: ReadSseStreamWithLimitOptions): SseByteGuard;
+//#endregion
+export { FirstStreamEventAbortController, FirstStreamEventInternalOptions, FirstStreamEventTimeoutContext, OpenAICodexJwtPayload, ReadSseStreamWithLimitOptions, ReasoningTagTextDelta, ReasoningTagTextPartitioner, SessionResourceCleanup, SseByteGuard, SseStreamOverflow, applyProviderReportedUsageCost, calculateCost, clampThinkingLevel, cleanupSessionResources, clearApiProviders, complete, completeSimple, createDeferredEventBuffer, createFirstStreamEventAbortController, createFirstStreamEventTimeoutError, createReasoningTagTextPartitioner, createSseByteGuard, decodeOpenAICodexJwtPayload, defaultApiRegistry, defaultLlmRuntime, findEnvKeys, getApiProvider, getApiProviders, getEnvApiKey, getFirstStreamEventTimeoutHandler, getFirstStreamEventTimeoutMs, getSupportedThinkingLevels, headersToRecord, isConfiguredContextSizeOverflowError, isContextOverflow, modelsAreEqual, notifyLlmRequestActivity, onLlmRequestActivity, parseJsonWithRepair, parseStreamingJson, registerApiProvider, registerSessionResourceCleanup, repairJson, resolveOpenAICodexAccountId, sanitizeSurrogates, shortHash, stream, streamSimple, unregisterApiProviders, withFirstStreamEventTimeout };