@opencode-ai/ai 0.0.0-beta-18050 → 0.0.0-beta-18138

package/dist/protocols/openai-chat.js

@@ -33,7 +33,12 @@ const OpenAIChatFunction = Schema.Struct({
 });
 const OpenAIChatTool = Schema.Struct({
     type: Schema.tag("function"),
-    function: OpenAIChatFunction,
+    function: Schema.Struct({
+        name: Schema.String,
+        description: Schema.String,
+        parameters: JsonObject,
+        strict: Schema.optional(Schema.Boolean),
+    }),
     cache_control: Schema.optional(OpenAIChatCacheControl),
 });
 const OpenAIChatAssistantToolCall = Schema.Struct({
@@ -103,6 +108,7 @@ export const bodyFields = {
     store: Schema.optional(Schema.Boolean),
     prompt_cache_key: Schema.optional(Schema.String),
     reasoning_effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
+    tool_stream: Schema.optional(Schema.Boolean),
     max_completion_tokens: Schema.optional(Schema.Number),
     max_tokens: Schema.optional(Schema.Number),
     temperature: Schema.optional(Schema.Number),
@@ -170,12 +176,13 @@ export const OpenAIChatEvent = Schema.Struct({
     usage: optionalNull(OpenAIChatUsage),
     error: optionalNull(OpenAIChatError),
 });
-const lowerTool = (tool, inputSchema, options) => ({
+const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
     type: "function",
     function: {
         name: tool.name,
         description: tool.description,
         parameters: inputSchema,
+        ...(supportsStrictMode ? { strict: false } : {}),
     },
     cache_control: options.cacheControl?.(tool.cache),
 });
@@ -413,11 +420,110 @@ const hasToolHistory = (messages) => {
     }
     return false;
 };
-const lowerOptions = (request) => {
+// Derive `max_tokens` vs `max_completion_tokens` from provider/baseURL when
+// explicit `compatibility.maxTokensField` is not set. Aligned with
+// models.dev provider naming: DeepSeek, Moonshot AI, Together AI, ZAI
+// (Zhipu + Coding Plan variants), Nvidia, Cerebras, Chutes, etc. still
+// require `max_tokens`.
+const detectMaxTokensField = (provider, baseURL) => {
+    const p = provider.toLowerCase();
+    const url = (baseURL ?? "").toLowerCase();
+    if (p === "deepseek" ||
+        url.includes("deepseek.com") ||
+        p === "moonshotai" ||
+        url.includes("api.moonshot.ai") ||
+        p === "togetherai" ||
+        url.includes("api.together.") ||
+        p === "zai" ||
+        p === "zai-coding-plan" ||
+        p === "zhipuai" ||
+        p === "zhipuai-coding-plan" ||
+        url.includes("api.z.ai") ||
+        url.includes("open.bigmodel.cn") ||
+        p === "nvidia" ||
+        url.includes("integrate.api.nvidia.com") ||
+        p === "cerebras" ||
+        url.includes("cerebras.ai") ||
+        url.includes("llm.chutes.ai") ||
+        p === "chutes" ||
+        p === "cloudflare-ai-gateway" ||
+        url.includes("gateway.ai.cloudflare.com") ||
+        p === "cloudflare-workers-ai" ||
+        url.includes("api.cloudflare.com"))
+        return "max_tokens";
+    return "max_completion_tokens";
+};
+const detectSupportsStore = (provider, baseURL) => {
+    const p = provider.toLowerCase();
+    const url = (baseURL ?? "").toLowerCase();
+    const isNvidia = p === "nvidia" || url.includes("integrate.api.nvidia.com");
+    const isMoonshot = p === "moonshotai" || p === "moonshotai-cn" || url.includes("api.moonshot.");
+    const isTogether = p === "togetherai" || p === "together" || url.includes("api.together.");
+    const isZai = p === "zai" ||
+        p === "zai-coding-plan" ||
+        p === "zhipuai" ||
+        p === "zhipuai-coding-plan" ||
+        url.includes("api.z.ai") ||
+        url.includes("open.bigmodel.cn");
+    const isDeepSeek = p === "deepseek" || url.includes("deepseek.com");
+    const isCerebras = p === "cerebras" || url.includes("cerebras.ai");
+    const isXai = p === "xai" || url.includes("api.x.ai");
+    const isChutes = p === "chutes" || url.includes("chutes.ai");
+    const isCloudflareWorkersAI = p === "cloudflare-workers-ai" || url.includes("api.cloudflare.com");
+    const isCloudflareAiGateway = p === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com");
+    const isVercelAiGateway = p === "vercel-ai-gateway" || url.includes("ai-gateway.vercel.sh") || url.includes("vercel.sh");
+    const isAntLing = p === "ant-ling" || url.includes("api.ant-ling.com");
+    const isOpencode = p === "opencode" || url.includes("opencode.ai");
+    const isNonStandard = isNvidia ||
+        isCerebras ||
+        isXai ||
+        isTogether ||
+        isChutes ||
+        isDeepSeek ||
+        isZai ||
+        isMoonshot ||
+        isOpencode ||
+        isCloudflareWorkersAI ||
+        isCloudflareAiGateway ||
+        isVercelAiGateway ||
+        isAntLing;
+    return !isNonStandard;
+};
+const detectSupportsUsageInStreaming = () => true;
+const detectSupportsStrictMode = (provider, baseURL) => {
+    const p = provider.toLowerCase();
+    const url = (baseURL ?? "").toLowerCase();
+    const isMoonshot = p === "moonshotai" || p === "moonshotai-cn" || url.includes("api.moonshot.");
+    const isTogether = p === "togetherai" || p === "together" || url.includes("api.together.");
+    const isCloudflareAiGateway = p === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com");
+    const isNvidia = p === "nvidia" || url.includes("integrate.api.nvidia.com");
+    return !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia;
+};
+const detectZaiToolStream = (provider, baseURL, modelID) => {
+    const p = provider.toLowerCase();
+    const url = (baseURL ?? "").toLowerCase();
+    const isZai = p === "zai" ||
+        p === "zai-coding-plan" ||
+        p === "zhipuai" ||
+        p === "zhipuai-coding-plan" ||
+        url.includes("api.z.ai") ||
+        url.includes("open.bigmodel.cn");
+    if (!isZai)
+        return false;
+    const id = modelID.toLowerCase();
+    if (id === "glm-4.5" || id === "glm-4.5-air" || id === "glm-4.5-flash" || id === "glm-4.5v")
+        return false;
+    return true;
+};
+const lowerOptions = (request, supportsStore) => {
     const options = OpenAIOptions.resolve(request);
     const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
     return {
-        ...(options.store !== undefined ? { store: options.store } : {}),
+        ...(supportsStore && options.store !== undefined ? { store: options.store } : {}),
+        // For providers that support `store`, ensure stateless `store:false` is sent
+        // even when no explicit `providerOptions.store` was supplied, mirroring the
+        // native OpenAI Chat default. Non-standard providers omit `store` entirely.
+        ...(supportsStore && options.store === undefined ? { store: false } : {}),
         ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
         ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
     };
@@ -430,8 +536,17 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
         return yield* ProviderShared.invalidRequest(`OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`);
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
-    const maxTokensField = request.model.compatibility?.maxTokensField ?? "max_tokens";
+    const provider = String(request.model.provider);
+    const baseURL = request.model.route.endpoint.baseURL;
+    const detectedMaxTokensField = detectMaxTokensField(provider, baseURL);
+    const maxTokensField = request.model.compatibility?.maxTokensField ?? detectedMaxTokensField;
+    const supportsStore = request.model.compatibility?.supportsStore ?? detectSupportsStore(provider, baseURL);
+    const supportsUsageInStreaming = request.model.compatibility?.supportsUsageInStreaming ?? detectSupportsUsageInStreaming();
+    const supportsStrictMode = request.model.compatibility?.supportsStrictMode ?? detectSupportsStrictMode(provider, baseURL);
+    const zaiToolStream = request.model.compatibility?.zaiToolStream ??
+        detectZaiToolStream(provider, baseURL, request.model.id);
     const hasHistory = hasToolHistory(request.messages);
+    const hasActiveTools = request.tools.length > 0;
     return {
         model: request.model.id,
         messages: yield* lowerMessages(request, options),
@@ -439,10 +554,11 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
             ? hasHistory
                 ? []
                 : undefined
-            : request.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options)),
+            : request.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility), options, supportsStrictMode)),
         tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
-        stream_options: { include_usage: true },
+        ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),
+        ...(zaiToolStream && hasActiveTools ? { tool_stream: true } : {}),
         ...(maxTokensField === "max_completion_tokens"
             ? { max_completion_tokens: generation?.maxTokens }
             : { max_tokens: generation?.maxTokens }),
@@ -452,7 +568,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
         presence_penalty: generation?.presencePenalty,
         seed: generation?.seed,
         stop: generation?.stop,
-        ...lowerOptions(request),
+        ...lowerOptions(request, supportsStore),
     };
 });
 // =============================================================================

package/dist/protocols/openai-compatible-chat.d.ts

@@ -73,11 +73,12 @@ export declare const route: Route<{
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
         readonly function: {
-            readonly name: string;
             readonly description: string;
+            readonly name: string;
             readonly parameters: {
                 readonly [x: string]: unknown;
             };
+            readonly strict?: boolean | undefined;
         };
         readonly type: "function";
         readonly cache_control?: {
@@ -101,6 +102,7 @@ export declare const route: Route<{
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>;

package/dist/protocols/openai-compatible-responses.d.ts

@@ -94,6 +94,7 @@ export declare const route: Route<{
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -117,7 +118,6 @@ export declare const route: Route<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/protocols/openai-responses.d.ts

@@ -230,6 +230,7 @@ export declare const protocol: Protocol<{
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -255,7 +256,6 @@ export declare const protocol: Protocol<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -413,6 +413,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -438,7 +439,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -542,6 +542,7 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -567,7 +568,6 @@ export declare const channelTransport: (options: import("./open-responses-channe
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -671,6 +671,7 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -696,7 +697,6 @@ export declare const transport: import("../route/transport/index.js").Transport<
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
@@ -800,6 +800,7 @@ export declare const route: Route<{
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -825,7 +826,6 @@ export declare const route: Route<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/protocols/openai-responses.js

@@ -43,9 +43,27 @@ const OpenAIResponsesBody = Schema.Struct({
     ...OpenAIResponsesCoreFields,
     stream: Schema.Literal(true),
 });
+// Replayed items are paired with stored server state by id, so a foreign or
+// synthetic token can fail request validation even when `call_id` pairing is
+// intact. Only resend ids in each item kind's own grammar; hosted tool
+// references keep generic validation because every hosted tool mints its own
+// prefix. The same allowlist approach codex uses before resending history
+// (codex-rs core/src/client.rs, `prepare_response_items_for_request`).
+const ITEM_ID_PREFIXES = {
+    message: ["msg_"],
+    reasoning: ["rs_"],
+    "function-call": ["fc_"],
+    // Every hosted tool mints its own id prefix, so references keep generic
+    // validation only.
+    reference: [],
+};
 const extension = {
     id: ADAPTER,
     name: NAME,
+    acceptsItemID: (kind, id) => {
+        const prefixes = ITEM_ID_PREFIXES[kind];
+        return prefixes.length === 0 || prefixes.some((prefix) => id.startsWith(prefix));
+    },
 };
 const nativeImageToolInput = (tool) => {
     const native = tool.native?.openai;
@@ -75,8 +93,10 @@ const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NA
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request) {
     const body = yield* OpenResponses.fromRequestWithExtension(LLMRequest.update(request, { tools: [], toolChoice: undefined }), extension);
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
+    const parallelToolCalls = OpenResponses.resolveParallelToolCalls(request);
     return {
         ...body,
+        ...(parallelToolCalls === undefined ? {} : { parallel_tool_calls: parallelToolCalls }),
         tools: request.tools.length === 0
             ? undefined
             : yield* Effect.forEach(request.tools, (tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
@@ -117,14 +137,10 @@ const HOSTED_TOOLS = {
     },
 };
 const step = (state, event) => {
-    if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
+    if (event.type === "response.reasoning_text.delta")
         return event.item_id
             ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
             : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
-    if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-        return event.item_id
-            ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
         return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS);
     return OpenResponses.step(state, event);

package/dist/protocols/utils/bedrock-media.d.ts

@@ -29,6 +29,7 @@ export declare const lower: (part: {
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+    readonly cache?: import("../../schema/options.js").CacheHint | undefined;
     readonly filename?: string | undefined;
 }) => Effect.Effect<{
     readonly document: {

package/dist/protocols/utils/partial-json-options.d.ts

@@ -0,0 +1,62 @@
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello `
+ */
+export declare const STR = 1;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+export declare const NUM = 2;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+export declare const ARR = 4;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+export declare const OBJ = 8;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+export declare const NULL = 16;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+export declare const BOOL = 32;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+export declare const NAN = 64;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+export declare const INFINITY = 128;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+export declare const _INFINITY = 256;
+export declare const INF: number;
+export declare const SPECIAL: number;
+export declare const ATOM: number;
+export declare const COLLECTION: number;
+export declare const ALL: number;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most cases is the best option.
+ */
+export declare const Allow: {
+    STR: number;
+    NUM: number;
+    ARR: number;
+    OBJ: number;
+    NULL: number;
+    BOOL: number;
+    NAN: number;
+    INFINITY: number;
+    _INFINITY: number;
+    INF: number;
+    SPECIAL: number;
+    ATOM: number;
+    COLLECTION: number;
+    ALL: number;
+};
+export default Allow;

package/dist/protocols/utils/partial-json-options.js

@@ -0,0 +1,52 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js/blob/main/src/options.ts
+ * Licensed under the MIT License; see partial-json.ts for the complete notice.
+ */
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello `
+ */
+export const STR = 0b000000001;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+export const NUM = 0b000000010;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+export const ARR = 0b000000100;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+export const OBJ = 0b000001000;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+export const NULL = 0b000010000;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+export const BOOL = 0b000100000;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+export const NAN = 0b001000000;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+export const INFINITY = 0b010000000;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+export const _INFINITY = 0b100000000;
+export const INF = INFINITY | _INFINITY;
+export const SPECIAL = NULL | BOOL | INF | NAN;
+export const ATOM = STR | NUM | SPECIAL;
+export const COLLECTION = ARR | OBJ;
+export const ALL = ATOM | COLLECTION;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most cases is the best option.
+ */
+export const Allow = { STR, NUM, ARR, OBJ, NULL, BOOL, NAN, INFINITY, _INFINITY, INF, SPECIAL, ATOM, COLLECTION, ALL };
+export default Allow;

package/dist/protocols/utils/partial-json.d.ts

@@ -0,0 +1,8 @@
+export * from "./partial-json-options.js";
+export declare class PartialJSON extends Error {
+}
+export declare class MalformedJSON extends Error {
+}
+/** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
+export declare function parseJSON(jsonString: string, allowPartial?: number): unknown;
+export declare const parse: typeof parseJSON;