@opencode-ai/ai 0.0.0-dev-18229 → 0.0.0-dev-18231

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

@@ -19,6 +19,35 @@ declare const MediaInput: Schema.Union<readonly [Schema.Struct<{
 export type MediaInput = Schema.Schema.Type<typeof MediaInput>;
 export declare const MessagePhase: Schema.NullOr<Schema.Literals<readonly ["commentary", "final_answer"]>>;
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>;
+export declare const HostedToolItem: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"web_search_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly action: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"file_search_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly queries: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly results: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"code_interpreter_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly container_id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly outputs: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"mcp_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly server_label: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly arguments: Schema.optional<Schema.String>;
+    readonly output: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly error: Schema.optional<Schema.Unknown>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>;
+export type HostedToolItem = Schema.Schema.Type<typeof HostedToolItem>;
 export declare const InputItem: Schema.Union<readonly [Schema.Struct<{
     readonly role: Schema.tag<"system">;
     readonly content: Schema.String;
@@ -56,9 +85,6 @@ export declare const InputItem: Schema.Union<readonly [Schema.Struct<{
         readonly text: Schema.String;
     }>>;
     readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"item_reference">;
-    readonly id: Schema.String;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"function_call">;
     readonly id: Schema.optionalKey<Schema.String>;
@@ -83,9 +109,41 @@ export declare const InputItem: Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.tag<"input_video">;
         readonly video_url: Schema.String;
     }>]>>]>;
-}>]>;
+}>, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"web_search_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly action: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"file_search_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly queries: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly results: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"code_interpreter_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly container_id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly outputs: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.tag<"mcp_call">;
+    readonly id: Schema.String;
+    readonly status: Schema.optional<Schema.String>;
+    readonly server_label: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    readonly arguments: Schema.optional<Schema.String>;
+    readonly output: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly error: Schema.optional<Schema.Unknown>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>]>;
 type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>;
-type LoweredInputItem = OpenResponsesInputItem | {
+export type ExtendedHostedToolItem = {
+    readonly type: string;
+    readonly id: string;
+    readonly [key: string]: unknown;
+};
+type LoweredInputItem = OpenResponsesInputItem | ExtendedHostedToolItem | {
     readonly type: "message";
     readonly id?: string;
     readonly role: "assistant";
@@ -152,9 +210,6 @@ export declare const coreFields: {
             readonly text: Schema.String;
         }>>;
         readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"item_reference">;
-        readonly id: Schema.String;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"function_call">;
         readonly id: Schema.optionalKey<Schema.String>;
@@ -179,7 +234,34 @@ export declare const coreFields: {
             readonly type: Schema.tag<"input_video">;
             readonly video_url: Schema.String;
         }>]>>]>;
-    }>]>>;
+    }>, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"web_search_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly action: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"file_search_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly queries: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly results: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"code_interpreter_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly container_id: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly outputs: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"mcp_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly server_label: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly arguments: Schema.optional<Schema.String>;
+        readonly output: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly error: Schema.optional<Schema.Unknown>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>]>>;
     instructions: Schema.optional<Schema.String>;
     tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
@@ -265,9 +347,6 @@ declare const OpenResponsesBody: Schema.Struct<{
             readonly text: Schema.String;
         }>>;
         readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"item_reference">;
-        readonly id: Schema.String;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"function_call">;
         readonly id: Schema.optionalKey<Schema.String>;
@@ -292,7 +371,34 @@ declare const OpenResponsesBody: Schema.Struct<{
             readonly type: Schema.tag<"input_video">;
             readonly video_url: Schema.String;
         }>]>>]>;
-    }>]>>;
+    }>, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"web_search_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly action: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"file_search_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly queries: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly results: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"code_interpreter_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly container_id: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly outputs: Schema.optional<Schema.NullOr<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.tag<"mcp_call">;
+        readonly id: Schema.String;
+        readonly status: Schema.optional<Schema.String>;
+        readonly server_label: Schema.optional<Schema.String>;
+        readonly name: Schema.optional<Schema.String>;
+        readonly arguments: Schema.optional<Schema.String>;
+        readonly output: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly error: Schema.optional<Schema.Unknown>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>]>>;
     readonly instructions: Schema.optional<Schema.String>;
     readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly type: Schema.tag<"function">;
@@ -444,7 +550,7 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly headers: Schema.optional<Schema.Unknown>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type Event = Schema.Schema.Type<typeof Event>;
-export type ItemKind = "message" | "reasoning" | "function-call" | "reference";
+export type ItemKind = "message" | "reasoning" | "function-call" | "hosted-tool";
 export interface Extension {
     readonly id: string;
     readonly name: string;
@@ -453,6 +559,7 @@ export interface Extension {
         readonly media: ProviderShared.NormalizedMedia;
         readonly request: LLMRequest;
     }) => MediaInput | undefined;
+    readonly lowerHostedToolItem?: (item: unknown) => ExtendedHostedToolItem | undefined;
     readonly acceptsItemID?: (kind: ItemKind, id: string) => boolean;
 }
 export interface ParserState {
@@ -466,7 +573,6 @@ export interface ParserState {
     readonly messageItems: ReadonlySet<string>;
     readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
-    readonly store: boolean | undefined;
 }
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded";
 interface ReasoningStreamItem {
@@ -545,6 +651,43 @@ export declare const fromRequestWithExtension: (request: LLMRequest, extension:
 }, AIError, never>;
 export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
     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";
@@ -552,9 +695,6 @@ export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
         }[];
         readonly id?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
-    } | {
-        readonly type: "item_reference";
-        readonly id: string;
     } | {
         readonly role: "system";
         readonly content: string;
@@ -857,6 +997,43 @@ export declare const step: (state: ParserState, input: Event) => AIError | Effec
 export declare const initial: (request: LLMRequest, extension?: Extension) => ParserState;
 export declare const protocol: Protocol<{
     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";
@@ -864,9 +1041,6 @@ export declare const protocol: Protocol<{
         }[];
         readonly id?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
-    } | {
-        readonly type: "item_reference";
-        readonly id: string;
     } | {
         readonly role: "system";
         readonly content: string;
@@ -1039,6 +1213,43 @@ export declare const protocol: Protocol<{
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     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";
@@ -1046,9 +1257,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         }[];
         readonly id?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
-    } | {
-        readonly type: "item_reference";
-        readonly id: string;
     } | {
         readonly role: "system";
         readonly content: string;

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"),
@@ -343,7 +376,6 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (part, request, extens
 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 providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses";
     for (const message of request.messages) {
         if (message.role === "system") {
@@ -363,8 +395,7 @@ 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;
@@ -399,12 +430,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     const reasoning = lowerReasoning(part, providerMetadataKey, extension);
                     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];
                     if (existing) {
                         existing.summary.push(...reasoning.summary);
@@ -426,22 +451,25 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                 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 (acceptsItemID(extension, "hosted-tool", id) && 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", [
@@ -733,25 +761,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) {
@@ -1006,7 +1030,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-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;