@opencode-ai/ai 0.0.0-beta-18230 → 0.0.0-beta-18286

package/dist/protocols/open-responses.js

@@ -54,10 +54,43 @@ const OpenResponsesReasoningItem = Schema.Struct({
     summary: Schema.Array(OpenResponsesReasoningSummaryText),
     encrypted_content: optionalNull(Schema.String),
 });
-const OpenResponsesItemReference = Schema.Struct({
-    type: Schema.tag("item_reference"),
+const OpenResponsesWebSearchCall = Schema.StructWithRest(Schema.Struct({
+    type: Schema.tag("web_search_call"),
     id: Schema.String,
-});
+    status: Schema.optional(Schema.String),
+    action: optionalNull(JsonObject),
+}), [JsonObject]);
+const OpenResponsesFileSearchCall = Schema.StructWithRest(Schema.Struct({
+    type: Schema.tag("file_search_call"),
+    id: Schema.String,
+    status: Schema.optional(Schema.String),
+    queries: Schema.optional(Schema.Array(Schema.String)),
+    results: optionalNull(Schema.Array(JsonObject)),
+}), [JsonObject]);
+const OpenResponsesCodeInterpreterCall = Schema.StructWithRest(Schema.Struct({
+    type: Schema.tag("code_interpreter_call"),
+    id: Schema.String,
+    status: Schema.optional(Schema.String),
+    code: optionalNull(Schema.String),
+    container_id: optionalNull(Schema.String),
+    outputs: optionalNull(Schema.Array(JsonObject)),
+}), [JsonObject]);
+const OpenResponsesMCPCall = Schema.StructWithRest(Schema.Struct({
+    type: Schema.tag("mcp_call"),
+    id: Schema.String,
+    status: Schema.optional(Schema.String),
+    server_label: Schema.optional(Schema.String),
+    name: Schema.optional(Schema.String),
+    arguments: Schema.optional(Schema.String),
+    output: optionalNull(Schema.String),
+    error: Schema.optional(Schema.Unknown),
+}), [JsonObject]);
+export const HostedToolItem = Schema.Union([
+    OpenResponsesWebSearchCall,
+    OpenResponsesFileSearchCall,
+    OpenResponsesCodeInterpreterCall,
+    OpenResponsesMCPCall,
+]);
 // `function_call_output.output` accepts either a plain string or an ordered
 // array of content items so tools can return images and files in addition to text.
 // https://www.openresponses.org/reference
@@ -83,7 +116,6 @@ export const InputItem = Schema.Union([
         phase: Schema.optionalKey(MessagePhase),
     }),
     OpenResponsesReasoningItem,
-    OpenResponsesItemReference,
     Schema.Struct({
         type: Schema.tag("function_call"),
         id: Schema.optionalKey(Schema.String),
@@ -96,6 +128,7 @@ export const InputItem = Schema.Union([
         call_id: Schema.String,
         output: OpenResponsesFunctionCallOutput,
     }),
+    HostedToolItem,
 ]);
 export const Tool = Schema.Struct({
     type: Schema.tag("function"),
@@ -248,41 +281,36 @@ export const lowerToolChoice = (protocolName, toolChoice) => ProviderShared.matc
     required: () => "required",
     tool: (toolName) => ({ type: "function", name: toolName }),
 });
-// Servers validate item ids on replayed history, and a malformed or oversized
-// id can fail an otherwise valid request. Only server-issued tokens are worth
-// resending; anything else is treated as absent so the item is resent without
-// an id (or skipped, for items that cannot be expressed without one).
-const ITEM_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+// Server-issued item ids need a nonempty prefix and suffix, but the prefix is
+// provider-defined and does not necessarily identify the item's semantic type.
 const itemID = (providerMetadata, providerMetadataKey) => {
     const metadata = providerMetadata?.[providerMetadataKey];
-    return ProviderShared.isRecord(metadata) &&
-        typeof metadata.itemId === "string" &&
-        ITEM_ID_PATTERN.test(metadata.itemId)
-        ? metadata.itemId
-        : undefined;
+    if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string")
+        return undefined;
+    const separator = metadata.itemId.indexOf("_");
+    return separator > 0 && separator < metadata.itemId.length - 1 ? metadata.itemId : undefined;
 };
-const acceptsItemID = (extension, kind, id) => id !== undefined && (extension.acceptsItemID?.(kind, id) ?? true);
-const lowerToolCall = (part, providerMetadataKey, extension) => {
+const lowerToolCall = (part, providerMetadataKey) => {
     const id = itemID(part.providerMetadata, providerMetadataKey);
     return {
         type: "function_call",
-        ...(acceptsItemID(extension, "function-call", id) ? { id } : {}),
+        ...(id === undefined ? {} : { id }),
         call_id: part.id,
         name: part.name,
         arguments: ProviderShared.encodeJson(part.input),
     };
 };
-const lowerReasoning = (part, providerMetadataKey, extension) => {
+const lowerReasoning = (part, providerMetadataKey) => {
     const metadata = part.providerMetadata?.[providerMetadataKey];
-    const id = itemID(part.providerMetadata, providerMetadataKey);
-    if (!ProviderShared.isRecord(metadata) || !acceptsItemID(extension, "reasoning", id))
+    if (!ProviderShared.isRecord(metadata))
         return undefined;
+    const id = itemID(part.providerMetadata, providerMetadataKey);
     const encryptedContent = typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
         ? metadata.reasoningEncryptedContent
         : undefined;
     return {
         type: "reasoning",
-        id,
+        ...(id === undefined ? {} : { id }),
         summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
         encrypted_content: encryptedContent,
     };
@@ -341,9 +369,7 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (part, request, extens
     return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension));
 });
 const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request, extension) {
-    const system = request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }];
-    const input = [...system];
-    const store = OpenResponsesOptions.resolve(request).store;
+    const input = [];
     const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses";
     for (const message of request.messages) {
         if (message.role === "system") {
@@ -363,15 +389,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         if (message.role === "assistant") {
             const content = [];
             const reasoningItems = {};
-            const reasoningReferences = new Set();
-            const hostedToolReferences = new Set();
+            const hostedToolItems = new Set();
             const flushText = () => {
                 if (content.length === 0)
                     return;
                 const groups = content.reduce((groups, part) => {
                     const metadata = part.providerMetadata?.[providerMetadataKey];
-                    const rawID = itemID(part.providerMetadata, providerMetadataKey);
-                    const id = acceptsItemID(extension, "message", rawID) ? rawID : undefined;
+                    const id = itemID(part.providerMetadata, providerMetadataKey);
                     const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : undefined;
                     const group = groups.at(-1);
                     if (group && group.id === id && group.phase === phase)
@@ -396,23 +420,18 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                 }
                 if (part.type === "reasoning") {
                     flushText();
-                    const reasoning = lowerReasoning(part, providerMetadataKey, extension);
+                    const reasoning = lowerReasoning(part, providerMetadataKey);
                     if (!reasoning)
                         continue;
-                    if (store !== false) {
-                        if (!reasoningReferences.has(reasoning.id))
-                            input.push({ type: "item_reference", id: reasoning.id });
-                        reasoningReferences.add(reasoning.id);
-                        continue;
-                    }
-                    const existing = reasoningItems[reasoning.id];
+                    const existing = reasoning.id === undefined ? undefined : reasoningItems[reasoning.id];
                     if (existing) {
                         existing.summary.push(...reasoning.summary);
                         if (typeof reasoning.encrypted_content === "string")
                             existing.encrypted_content = reasoning.encrypted_content;
                         continue;
                     }
-                    reasoningItems[reasoning.id] = reasoning;
+                    if (reasoning.id !== undefined)
+                        reasoningItems[reasoning.id] = reasoning;
                     input.push(reasoning);
                     continue;
                 }
@@ -420,28 +439,31 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     flushText();
                     if (part.providerExecuted === true)
                         continue;
-                    input.push(lowerToolCall(part, providerMetadataKey, extension));
+                    input.push(lowerToolCall(part, providerMetadataKey));
                     continue;
                 }
                 if (part.type === "tool-result" && part.providerExecuted === true) {
                     flushText();
                     const id = itemID(part.providerMetadata, providerMetadataKey);
-                    const reference = acceptsItemID(extension, "reference", id) ? id : undefined;
-                    if (store !== false && reference && !hostedToolReferences.has(reference))
-                        input.push({ type: "item_reference", id: reference });
-                    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"
+                    const hosted = part.result.type !== "json"
+                        ? undefined
+                        : Schema.is(HostedToolItem)(part.result.value)
                             ? part.result.value
-                            : [{ type: "text", text: ProviderShared.toolResultText(part) }];
-                        input.push({
-                            role: "user",
-                            content: yield* Effect.forEach(content, (item) => lowerHostedToolResultContentItem(item, request, extension)),
-                        });
+                            : extension.lowerHostedToolItem?.(part.result.value);
+                    if (id !== undefined && hosted?.id === id) {
+                        if (!hostedToolItems.has(id)) {
+                            input.push(hosted);
+                            hostedToolItems.add(id);
+                        }
+                        continue;
                     }
-                    if (reference)
-                        hostedToolReferences.add(reference);
+                    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)),
+                    });
                     continue;
                 }
                 return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
@@ -468,10 +490,11 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 });
 const lowerOptions = (request) => {
     const options = OpenResponsesOptions.resolve(request);
+    const instructions = ProviderShared.joinText(request.system);
     const cacheKey = ProviderShared.promptCacheKey(request);
     const parallelToolCalls = resolveParallelToolCalls(request);
     return {
-        ...(options.instructions ? { instructions: options.instructions } : {}),
+        ...(instructions ? { instructions } : {}),
         ...(options.store !== undefined ? { store: options.store } : {}),
         ...(options.metadata ? { metadata: options.metadata } : {}),
         ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
@@ -675,26 +698,24 @@ const onOutputItemAdded = (state, event) => {
             events,
         ];
     }
-    if (item?.type !== "function_call" || !item.id)
+    if (item?.type !== "function_call" || !item.call_id)
         return [state, NO_EVENTS];
-    const metadata = providerMetadata(state, { itemId: item.id });
+    const id = item.id ?? item.call_id;
+    const metadata = item.id ? providerMetadata(state, { itemId: item.id }) : undefined;
     const events = [];
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
     return [
         {
             ...state,
             lifecycle,
-            tools: ToolStream.start(state.tools, item.id, {
-                id: item.call_id ?? item.id,
+            tools: ToolStream.start(state.tools, id, {
+                id: item.call_id,
                 name: item.name ?? "",
                 input: item.arguments ?? "",
                 providerMetadata: metadata,
             }),
         },
-        [
-            ...events,
-            LLMEvent.toolInputStart({ id: item.call_id ?? item.id, name: item.name ?? "", providerMetadata: metadata }),
-        ],
+        [...events, LLMEvent.toolInputStart({ id: item.call_id, name: item.name ?? "", providerMetadata: metadata })],
     ];
 };
 const onReasoningSummaryPartAdded = (state, event) => {
@@ -733,25 +754,21 @@ const onReasoningSummaryPartDone = (state, event) => {
     const item = state.reasoningItems[event.item_id];
     if (!item)
         return [state, NO_EVENTS];
-    const events = [];
     return [
         {
             ...state,
-            lifecycle: state.store !== false
-                ? Lifecycle.reasoningEnd(state.lifecycle, events, `${event.item_id}:${event.summary_index}`, providerMetadata(state, { itemId: event.item_id }))
-                : state.lifecycle,
             reasoningItems: {
                 ...state.reasoningItems,
                 [event.item_id]: {
                     ...item,
                     summaryParts: {
                         ...item.summaryParts,
-                        [event.summary_index]: state.store !== false ? "concluded" : "can-conclude",
+                        [event.summary_index]: "can-conclude",
                     },
                 },
             },
         },
-        events,
+        NO_EVENTS,
     ];
 };
 const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
@@ -801,18 +818,19 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         ];
     }
     if (item.type === "function_call") {
-        if (!item.id || !item.call_id || !item.name)
+        if (!item.call_id || !item.name)
             return [state, NO_EVENTS];
-        const tools = state.tools[item.id]
+        const id = item.id ?? item.call_id;
+        const tools = state.tools[id]
             ? state.tools
-            : ToolStream.start(state.tools, item.id, {
+            : ToolStream.start(state.tools, id, {
                 id: item.call_id,
                 name: item.name,
-                providerMetadata: providerMetadata(state, { itemId: item.id }),
+                providerMetadata: item.id ? providerMetadata(state, { itemId: item.id }) : undefined,
             });
         const result = item.arguments === undefined
-            ? yield* ToolStream.finish(state.id, tools, item.id)
-            : yield* ToolStream.finishWithInput(state.id, tools, item.id, item.arguments);
+            ? yield* ToolStream.finish(state.id, tools, id)
+            : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments);
         const events = [];
         const resultEvents = result.events ?? [];
         const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle;
@@ -855,9 +873,10 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
     const reconciled = event.type === "response.completed"
         ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
-            if (!item.id ||
-                ((item.type !== "function_call" || !current.tools[item.id]) &&
-                    (item.type !== "reasoning" || !current.reasoningItems[item.id])))
+            const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined);
+            if (!id ||
+                ((item.type !== "function_call" || !current.tools[id]) &&
+                    (item.type !== "reasoning" || !current.reasoningItems[id])))
                 return Effect.succeed([current, events]);
             return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
         })
@@ -967,8 +986,9 @@ export const step = (state, input) => {
     if (event.type === "response.output_item.added") {
         if (event.item?.type === "message" && !event.item.id)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
-        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && event.item?.id
-            ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: event.item.id } }
+        const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined);
+        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && id
+            ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
             : state, event));
     }
     if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
@@ -1006,7 +1026,6 @@ export const initial = (request, extension = BASE) => ({
     messageItems: new Set(),
     messagePhases: {},
     reasoningItems: {},
-    store: OpenResponsesOptions.resolve(request).store,
 });
 export const protocol = Protocol.make({
     id: ADAPTER,

package/dist/protocols/openai-chat.js

@@ -241,7 +241,7 @@ const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (mes
         };
     return { role: "user", content };
 });
-const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (message, configuredField, options = {}) {
+const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (message, configuredField, requireReasoning, options) {
     const content = [];
     const reasoning = [];
     const toolCalls = [];
@@ -267,22 +267,22 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
     const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible);
     const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails));
     const field = (() => {
-        if (configuredField !== undefined)
+        if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
             return configuredField;
         if (reasoning.length === 0)
-            return undefined;
+            return requireReasoning ? "reasoning_content" : undefined;
         if (observedField !== undefined)
             return observedField;
         if (nativeReasoning !== undefined)
             return "reasoning_content";
-        if (!fullyStructured)
+        if (!fullyStructured || requireReasoning)
             return "reasoning_content";
     })();
     const reasoningText = (() => {
         if (configuredField !== undefined)
-            return reasoning.length === 0 ? (nativeReasoning ?? "") : text;
+            return reasoning.length === 0 ? (nativeReasoning ?? (requireReasoning ? "" : undefined)) : text;
         if (reasoning.length === 0)
-            return nativeReasoning;
+            return nativeReasoning ?? (requireReasoning ? "" : undefined);
         return text;
     })();
     const cached = message.content.findLast((part) => "cache" in part && part.cache !== undefined);
@@ -326,11 +326,11 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
     }
     return { messages, images };
 });
-const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message, reasoningField, options = {}) {
+const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message, reasoningField, requireReasoning, options) {
     if (message.role === "user")
         return [yield* lowerUserMessage(message, options)];
     if (message.role === "assistant")
-        return [yield* lowerAssistantMessage(message, reasoningField, options)];
+        return [yield* lowerAssistantMessage(message, reasoningField, requireReasoning, options)];
     return (yield* lowerToolMessages(message, options)).messages;
 });
 const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request, options) {
@@ -350,6 +350,12 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
             : [{ role: "system", content: ProviderShared.joinText(request.system) }];
     const messages = [...system];
     const modelID = request.model.id.toLowerCase();
+    const requireReasoning = request.model.compatibility?.requireReasoning ??
+        (request.model.compatibility?.reasoningField !== undefined ||
+            request.model.provider === "deepseek" ||
+            request.model.route.endpoint.baseURL?.toLowerCase().includes("deepseek.com") ||
+            modelID.includes("deepseek"));
+    const reasoningField = request.model.compatibility?.reasoningField;
     const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family));
     const lowering = {
         ...options,
@@ -427,7 +433,7 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
             continue;
         }
         flushImages();
-        messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, lowering)));
+        messages.push(...(yield* lowerMessage(message, reasoningField, requireReasoning, lowering)));
     }
     flushImages();
     return messages;

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

@@ -7,6 +7,43 @@ export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageMod
  */
 export declare const route: Route<{
     readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
         readonly type: "reasoning";
         readonly summary: readonly {
             readonly type: "summary_text";
@@ -14,9 +51,6 @@ export declare const route: Route<{
         }[];
         readonly id?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
-    } | {
-        readonly type: "item_reference";
-        readonly id: string;
     } | {
         readonly role: "system";
         readonly content: string;