@opencode-ai/ai 0.0.0-dev-18017 → 0.0.0-dev-18039

package/dist/protocols/anthropic-messages.d.ts

@@ -15,6 +15,7 @@ export type ThinkingInput = {
     readonly type: "disabled";
 } | ({
     readonly type: "enabled";
+    readonly display?: "summarized" | "omitted";
 } & ({
     readonly budgetTokens: number;
     readonly budget_tokens?: number;
@@ -194,6 +195,7 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
     thinking: Schema.optional<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
+        readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"adaptive">;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
@@ -369,6 +371,7 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
@@ -611,6 +614,7 @@ export declare const route: Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/protocols/anthropic-messages.js

@@ -146,6 +146,7 @@ const AnthropicThinking = Schema.Union([
     Schema.Struct({
         type: Schema.tag("enabled"),
         budget_tokens: Schema.Number,
+        display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
     }),
     Schema.Struct({
         type: Schema.tag("adaptive"),
@@ -491,14 +492,11 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
     if (!ProviderShared.isRecord(input))
         return undefined;
-    if (input.type === "adaptive") {
-        const display = input.display === "summarized"
-            ? "summarized"
-            : input.display === "omitted"
-                ? "omitted"
-                : undefined;
+    const display = input.display === "summarized" || input.display === "omitted"
+        ? input.display
+        : undefined;
+    if (input.type === "adaptive")
         return { type: "adaptive", ...(display === undefined ? {} : { display }) };
-    }
     if (input.type === "disabled")
         return { type: "disabled" };
     if (input.type !== "enabled")
@@ -510,7 +508,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
             : undefined;
     if (budget === undefined)
         return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget };
+    return { type: "enabled", budget_tokens: budget, ...(display === undefined ? {} : { display }) };
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const generation = request.generation;

package/dist/protocols/open-responses-channel.js

@@ -57,6 +57,9 @@ const driver = (options, body) => {
                 responseID = created;
                 return { type: "frame", frame };
             }
+            // Keepalives carry no response state and may arrive before response.created.
+            if (event.type === "keepalive")
+                return { type: "frame", frame };
             if (!responseID)
                 return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} before response.created`, frame);
             if (event.response?.id && event.response.id !== responseID)

package/dist/protocols/open-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, ProviderInternalReason, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -234,7 +234,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         type: "function",
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.responses(inputSchema),
+        parameters: inputSchema,
         // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
@@ -416,8 +416,12 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     const id = itemID(part.providerMetadata, providerMetadataKey);
                     if (store !== false && id && !hostedToolReferences.has(id))
                         input.push({ type: "item_reference", id });
-                    if (store === false && part.result.type === "content") {
-                        const content = part.result.value;
+                    if (store === false) {
+                        // The server is not storing this exchange, so the tool outcome has to
+                        // travel in the input. Non-content results degrade to their text form.
+                        const content = part.result.type === "content"
+                            ? part.result.value
+                            : [{ type: "text", text: ProviderShared.toolResultText(part) }];
                         input.push({
                             role: "user",
                             content: yield* Effect.forEach(content, (item) => lowerHostedToolResultContentItem(item, request, extension)),
@@ -456,6 +460,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 });
 const lowerOptions = (request) => {
     const options = OpenResponsesOptions.resolve(request);
+    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
         ...(options.store !== undefined ? { store: options.store } : {}),
@@ -465,7 +470,7 @@ const lowerOptions = (request) => {
             ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
             : {}),
         ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
-        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+        ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
         ...(options.include ? { include: options.include } : {}),
         ...(options.reasoningEffort || options.reasoningSummary
             ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }
@@ -856,11 +861,18 @@ export const providerFailure = (id, event, fallback) => {
         : typeof event.status_code === "number"
             ? event.status_code
             : undefined;
+    const reason = event.type === "error" &&
+        event.error === undefined &&
+        event.response === undefined &&
+        summary === undefined &&
+        status === undefined
+        ? new ProviderInternalReason({ message })
+        : classifyProviderFailure({ message, code, status, rawBody: body });
     return new AIError({
         module: id,
         method: "stream",
         body,
-        reason: classifyProviderFailure({ message, code, status, rawBody: body }),
+        reason,
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);

package/dist/protocols/openai-chat.js

@@ -175,7 +175,7 @@ const lowerTool = (tool, inputSchema, options) => ({
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: ToolSchemaProjection.openAI(inputSchema),
+        parameters: inputSchema,
     },
     cache_control: options.cacheControl?.(tool.cache),
 });
@@ -415,9 +415,10 @@ const hasToolHistory = (messages) => {
 };
 const lowerOptions = (request) => {
     const options = OpenAIOptions.resolve(request);
+    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
     return {
         ...(options.store !== undefined ? { store: options.store } : {}),
-        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+        ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
         ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
     };
 };

package/dist/protocols/shared.d.ts

@@ -10,6 +10,8 @@ export declare const encodeJson: (input: unknown, options?: import("effect/Schem
 export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
+export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+export declare const clampPromptCacheKey: (key: string | undefined) => string | undefined;
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
  * multiple `tool-input-delta` chunks store the partial JSON input string here

package/dist/protocols/shared.js

@@ -13,6 +13,17 @@ const isJson = Schema.is(Schema.Json);
 export const JsonObject = Schema.Record(Schema.String, Schema.Unknown);
 export const optionalArray = (schema) => Schema.optional(Schema.Array(schema));
 export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
+export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+// OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
+// limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.
+export const clampPromptCacheKey = (key) => {
+    if (key === undefined)
+        return undefined;
+    const chars = Array.from(key);
+    if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
+        return key;
+    return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+};
 /**
  * `Usage.totalTokens` policy shared by every route. Honors a provider-
  * supplied total; otherwise falls back to `inputTokens + outputTokens` only

package/dist/protocols/utils/tool-schema.js

@@ -1,20 +1,5 @@
 import { isRecord } from "../../utils/record.js";
 import { GeminiToolSchema } from "./gemini-tool-schema.js";
-const removeNullSchemas = (value) => {
-    if (Array.isArray(value))
-        return value.map(removeNullSchemas);
-    if (!isRecord(value))
-        return value;
-    const fields = Object.fromEntries(Object.entries(value)
-        .filter(([key]) => key !== "anyOf")
-        .map(([key, field]) => [key, removeNullSchemas(field)]));
-    if (!Array.isArray(value.anyOf))
-        return fields;
-    const variants = value.anyOf.filter((variant) => !isRecord(variant) || variant.type !== "null").map(removeNullSchemas);
-    if (variants.length === 1 && isRecord(variants[0]))
-        return { ...fields, ...variants[0] };
-    return { ...fields, anyOf: variants };
-};
 const tupleItemsSchema = (items) => {
     const projected = items.map(moonshotNode);
     if (projected.length === 0)
@@ -47,19 +32,7 @@ const moonshot = (schema) => {
     const projected = moonshotNode(schema);
     return isRecord(projected) ? projected : {};
 };
-const openAI = (schema) => {
-    const variants = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : [];
-    const flattened = variants.length === 0
-        ? { ...schema, type: "object" }
-        : {
-            ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "anyOf")),
-            type: "object",
-            properties: variants.reduce((properties, variant) => ({ ...(isRecord(variant.properties) ? variant.properties : {}), ...properties }), {}),
-            additionalProperties: false,
-        };
-    const normalized = removeNullSchemas(flattened);
-    return isRecord(normalized) ? normalized : { type: "object" };
-};
+const openAI = (schema) => schema;
 const responses = openAI;
 const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
 const modelCompatibility = (schema, compatibility) => {

package/dist/providers/anthropic-compatible.d.ts

@@ -182,6 +182,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/anthropic.d.ts

@@ -166,6 +166,7 @@ export declare const routes: import("../route/client.js").Route<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/google-vertex-messages.d.ts

@@ -180,6 +180,7 @@ export declare const routes: Route<{
     thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
+        readonly display?: "summarized" | "omitted" | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;

package/dist/providers/openrouter.js

@@ -8,7 +8,7 @@ import { ProviderID } from "../schema/index.js";
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js";
 import * as OpenAIChat from "../protocols/openai-chat.js";
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js";
-import { isRecord } from "../protocols/shared.js";
+import { isRecord, ProviderShared } from "../protocols/shared.js";
 export const profile = OpenAICompatibleProfiles.profiles.openrouter;
 export const id = ProviderID.make(profile.provider);
 const ADAPTER = "openrouter";
@@ -39,11 +39,12 @@ export const protocol = Protocol.make({
                     reasoning_details: reasoningDetails,
                 };
             });
+            const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
             return {
                 ...body,
                 messages,
                 ...bodyOptions(request.providerOptions),
-                ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
+                ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
             };
         })),
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-18017",
+  "version": "0.0.0-dev-18039",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.111",
-    "@opencode-ai/http-recorder": "0.0.0-dev-18017",
+    "@opencode-ai/http-recorder": "0.0.0-dev-18039",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-dev-18017",
+    "@opencode-ai/schema": "0.0.0-dev-18039",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"