@opencode/ai 2.0.22 → 2.0.24

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

@@ -13,10 +13,61 @@ export declare const ContextManagement: Schema.$Array<Schema.Struct<{
 export type ContextManagement = typeof ContextManagement.Type;
 declare const OpenAIResponsesBody: Schema.Struct<{
     readonly stream: Schema.Literal<true>;
-    readonly input: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly tools: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.tag<"function">;
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly strict: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"namespace">;
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly tools: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.tag<"function">;
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly strict: Schema.optional<Schema.Boolean>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
+        readonly action: Schema.optional<Schema.Literals<readonly ["auto", "generate", "edit"]>>;
+        readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
+        readonly input_fidelity: Schema.optional<Schema.Literals<readonly ["low", "high"]>>;
+        readonly output_compression: Schema.optional<Schema.Int>;
+        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
+        readonly partial_images: Schema.optional<Schema.Int>;
+        readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
+        readonly size: Schema.optional<Schema.String>;
+    }>]>>>;
+    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
+        readonly type: Schema.tag<"function">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"allowed_tools">;
+        readonly mode: Schema.Literals<readonly ["auto", "none", "required"]>;
+        readonly tools: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.tag<"function">;
+            readonly name: Schema.String;
+        }>>;
+    }>]>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
+    }>]>>;
+    readonly context_management: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"compaction">;
+        readonly compact_threshold: Schema.optional<Schema.Int>;
+    }>>>;
+    readonly model: Schema.String;
+    readonly input: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"compaction">;
         readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
         readonly encrypted_content: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"configuration_update">;
+        readonly reasoning: Schema.Struct<{
+            readonly effort: Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
+        }>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"message">;
         readonly role: Schema.tag<"system">;
@@ -116,77 +167,10 @@ declare const OpenAIResponsesBody: Schema.Struct<{
         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>]>]>]>, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
-        readonly type: Schema.tag<"computer_call">;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.String;
         readonly id: Schema.String;
-        readonly status: Schema.optional<Schema.String>;
-        readonly call_id: Schema.optional<Schema.String>;
-        readonly action: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>;
-        readonly pending_safety_checks: Schema.optional<Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
-        readonly type: Schema.tag<"web_search_preview_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<"image_generation_call">;
-        readonly id: Schema.String;
-        readonly status: Schema.optional<Schema.String>;
-        readonly result: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
-        readonly revised_prompt: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>, Schema.Struct<{
-        readonly type: Schema.Literal<"configuration_update">;
-        readonly reasoning: Schema.Struct<{
-            readonly effort: Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
-        }>;
-    }>]>>;
-    readonly tools: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.tag<"function">;
-        readonly name: Schema.String;
-        readonly description: Schema.String;
-        readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly strict: Schema.optional<Schema.Boolean>;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"namespace">;
-        readonly name: Schema.String;
-        readonly description: Schema.String;
-        readonly tools: Schema.$Array<Schema.Struct<{
-            readonly type: Schema.tag<"function">;
-            readonly name: Schema.String;
-            readonly description: Schema.String;
-            readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
-            readonly strict: Schema.optional<Schema.Boolean>;
-        }>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"image_generation">;
-        readonly action: Schema.optional<Schema.Literals<readonly ["auto", "generate", "edit"]>>;
-        readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
-        readonly input_fidelity: Schema.optional<Schema.Literals<readonly ["low", "high"]>>;
-        readonly output_compression: Schema.optional<Schema.Int>;
-        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
-        readonly partial_images: Schema.optional<Schema.Int>;
-        readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
-        readonly size: Schema.optional<Schema.String>;
-    }>]>>>;
-    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
-        readonly type: Schema.tag<"function">;
-        readonly name: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"allowed_tools">;
-        readonly mode: Schema.Literals<readonly ["auto", "none", "required"]>;
-        readonly tools: Schema.$Array<Schema.Struct<{
-            readonly type: Schema.tag<"function">;
-            readonly name: Schema.String;
-        }>>;
-    }>]>, Schema.Struct<{
-        readonly type: Schema.tag<"image_generation">;
-    }>]>>;
-    readonly context_management: Schema.optional<Schema.$Array<Schema.Struct<{
-        readonly type: Schema.Literal<"compaction">;
-        readonly compact_threshold: Schema.optional<Schema.Int>;
-    }>>>;
-    readonly model: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>>;
     readonly instructions: Schema.optional<Schema.String>;
     readonly store: Schema.optional<Schema.Boolean>;
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -262,6 +246,10 @@ export declare const protocol: Protocol<{
         readonly reasoning: {
             readonly effort: OpenResponsesOptions.ReasoningEffort;
         };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -338,34 +326,6 @@ export declare const protocol: Protocol<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "computer_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-        readonly call_id?: string | undefined;
-        readonly pending_safety_checks?: readonly {
-            readonly [x: string]: unknown;
-        }[] | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_search_preview_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly result?: string | null | undefined;
-        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -434,9 +394,10 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -444,7 +405,6 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, string, {
     readonly [x: string]: unknown;
@@ -464,18 +424,21 @@ export declare const protocol: Protocol<{
             readonly name?: string | undefined;
             readonly namespace?: string | undefined;
             readonly arguments?: string | undefined;
-            readonly encrypted_content?: string | null | undefined;
             readonly call_id?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
         }[] | undefined;
         readonly error?: unknown;
         readonly usage?: {
+            readonly [x: string]: unknown;
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
             readonly output_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly reasoning_tokens?: number | undefined;
             } | null | undefined;
             readonly total_tokens?: number | undefined;
             readonly input_tokens_details?: {
+                readonly [x: string]: unknown;
                 readonly cached_tokens?: number | undefined;
                 readonly cache_write_tokens?: number | undefined;
             } | null | undefined;
@@ -492,8 +455,8 @@ export declare const protocol: Protocol<{
         readonly name?: string | undefined;
         readonly namespace?: string | undefined;
         readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
     } | null | undefined;
     readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
@@ -545,6 +508,10 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly reasoning: {
             readonly effort: OpenResponsesOptions.ReasoningEffort;
         };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -621,34 +588,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "computer_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-        readonly call_id?: string | undefined;
-        readonly pending_safety_checks?: readonly {
-            readonly [x: string]: unknown;
-        }[] | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_search_preview_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly result?: string | null | undefined;
-        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -717,9 +656,10 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -727,7 +667,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, string>;
 export declare const channelTransport: (options: import("./open-responses-channel.js").Options) => import("../route/transport/index.js").Transport<{
@@ -773,6 +712,10 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly reasoning: {
             readonly effort: OpenResponsesOptions.ReasoningEffort;
         };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -849,34 +792,6 @@ export declare const channelTransport: (options: import("./open-responses-channe
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "computer_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-        readonly call_id?: string | undefined;
-        readonly pending_safety_checks?: readonly {
-            readonly [x: string]: unknown;
-        }[] | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_search_preview_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly result?: string | null | undefined;
-        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -945,9 +860,10 @@ export declare const channelTransport: (options: import("./open-responses-channe
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -955,7 +871,6 @@ export declare const channelTransport: (options: import("./open-responses-channe
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, import("./open-responses-channel.js").Prepared, string>;
 export declare const transport: import("../route/transport/index.js").Transport<{
@@ -1001,6 +916,10 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly reasoning: {
             readonly effort: OpenResponsesOptions.ReasoningEffort;
         };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -1077,34 +996,6 @@ export declare const transport: import("../route/transport/index.js").Transport<
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "computer_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-        readonly call_id?: string | undefined;
-        readonly pending_safety_checks?: readonly {
-            readonly [x: string]: unknown;
-        }[] | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_search_preview_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly result?: string | null | undefined;
-        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -1173,9 +1064,10 @@ export declare const transport: import("../route/transport/index.js").Transport<
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -1183,7 +1075,6 @@ export declare const transport: import("../route/transport/index.js").Transport<
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, import("./open-responses-channel.js").Prepared, string>;
 export declare const route: Route<{
@@ -1229,6 +1120,10 @@ export declare const route: Route<{
         readonly reasoning: {
             readonly effort: OpenResponsesOptions.ReasoningEffort;
         };
+    } | {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id: string;
     } | {
         readonly type: "reasoning";
         readonly summary: readonly {
@@ -1305,34 +1200,6 @@ export declare const route: Route<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "computer_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-        readonly call_id?: string | undefined;
-        readonly pending_safety_checks?: readonly {
-            readonly [x: string]: unknown;
-        }[] | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "web_search_preview_call";
-        readonly status?: string | undefined;
-        readonly action?: {
-            readonly [x: string]: unknown;
-        } | null | undefined;
-    } | {
-        readonly [x: string]: unknown;
-        readonly id: string;
-        readonly type: "image_generation_call";
-        readonly status?: string | undefined;
-        readonly result?: string | null | undefined;
-        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -1401,9 +1268,10 @@ export declare const route: Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly max_output_tokens?: number | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-    readonly store?: boolean | undefined;
     readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
     readonly stream_options?: {
@@ -1411,7 +1279,6 @@ export declare const route: Route<{
     } | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
 }, import("./open-responses-channel.js").Prepared, {
     endpoint: import("../route/client.js").CompactOperation;

package/dist/protocols/openai-responses.js

@@ -81,14 +81,8 @@ const OpenAIResponsesToolChoice = Schema.Union([
     OpenResponses.ToolChoice,
     Schema.Struct({ type: Schema.tag("image_generation") }),
 ]);
-const OpenAIResponsesInputItem = Schema.Union([
-    OpenResponses.InputItem,
-    OpenAIResponsesHostedToolItem,
-    OpenResponses.ConfigurationUpdate,
-]);
 const OpenAIResponsesCoreFields = {
     ...OpenResponses.coreFields,
-    input: Schema.Array(OpenAIResponsesInputItem),
     tools: optionalArray(OpenAIResponsesTools),
     tool_choice: Schema.optional(OpenAIResponsesToolChoice),
     context_management: Schema.optional(Schema.Array(Schema.Struct({
@@ -104,7 +98,7 @@ const OpenAIResponsesBody = Schema.Struct({
 export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compaction_trigger") });
 const CheckpointBody = Schema.Struct({
     ...OpenAIResponsesBody.fields,
-    input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
+    input: Schema.Array(Schema.Union([OpenResponses.InputItem, CompactionTrigger])),
 });
 const adapter = {
     id: ADAPTER,
@@ -132,7 +126,7 @@ const nativeImageTool = (tool) => {
     const native = nativeImageToolInput(tool);
     return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined;
 };
-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool) {
+const lowerTool = Effect.fnUntraced(function* (tool) {
     const native = nativeImageToolInput(tool);
     if (native !== undefined) {
         if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
@@ -143,7 +137,7 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool) {
 });
 // Native namespaces hold only function tools, so deeper levels flatten into
 // the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool) {
+const lowerToolEntry = Effect.fnUntraced(function* (tool) {
     if (tool.type === "tool")
         return yield* lowerTool(tool);
     // OpenAI requires a namespace description; fall back to a generic one so a
@@ -164,12 +158,11 @@ const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NA
         ? { type: "image_generation" }
         : { type: "function", name },
 });
-const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesBody));
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
     const options = OpenResponsesOptions.resolve(request);
     const updates = resolveEffortUpdates(request, options.reasoningEffort);
-    return yield* decodeBody({
+    return {
         ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
         ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
         context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
@@ -178,7 +171,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
             ? undefined
             : (OpenResponses.allowedToolChoice(request) ??
                 (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined)),
-    });
+    };
 });
 const checkpointBody = {
     schema: CheckpointBody,
@@ -198,7 +191,7 @@ const checkpointBody = {
         };
     }),
 };
-const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
+const hostedToolResult = Effect.fnUntraced(function* (item) {
     const isError = item.error !== undefined && item.error !== null;
     if (item.type === "image_generation_call" && item.result) {
         yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64", undefined, cause)));

package/dist/protocols/openai-speech.js

@@ -51,7 +51,7 @@ const fromRequest = Effect.fn("OpenAISpeech.fromRequest")(function* (request) {
 // 6. Stream parsing
 // ---------------------------------------------------------------------------
 const isSse = (body) => body.type === "json" && body.value.stream_format === "sse";
-const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
+const onEvent = Effect.fnUntraced(function* (state, frame) {
     const event = yield* decodeEvent(frame);
     if (event.type === "speech.audio.delta")
         return SpeechStream.delta(state, event.audio);

package/dist/protocols/openai-transcription.js

@@ -131,7 +131,7 @@ const segment = (value) => ({
     endSeconds: value.end,
     speaker: value.speaker,
 });
-const onEvent = Effect.fn("OpenAITranscription.onEvent")(function* (state, frame) {
+const onEvent = Effect.fnUntraced(function* (state, frame) {
     if (!EVENT_TYPES.has((yield* decodeEventType(frame)).type))
         return [state, []];
     const event = yield* decodeEvent(frame);

package/dist/protocols/shared.js

@@ -108,7 +108,7 @@ export const wrapSystemUpdate = (parts) => `<system-update>\n${escapeSystemUpdat
  * raw retrieved, tool, or web content into privileged updates: keep untrusted
  * data in ordinary user/tool messages instead.
  */
-export const systemUpdateText = Effect.fn("ProviderShared.systemUpdateText")(function* (route, message) {
+export const systemUpdateText = Effect.fnUntraced(function* (route, message) {
     const content = [];
     for (const part of message.content) {
         if (!supportsContent(part, ["text"]))
@@ -118,7 +118,7 @@ export const systemUpdateText = Effect.fn("ProviderShared.systemUpdateText")(fun
     return content;
 });
 /** Lower an unsupported privileged update into visible, in-order user text. */
-export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate")(function* (route, message) {
+export const wrappedSystemUpdate = Effect.fnUntraced(function* (route, message) {
     const content = yield* systemUpdateText(route, message);
     return { type: "text", text: wrapSystemUpdate(content), cache: content.at(-1)?.cache };
 });

package/dist/protocols/stability-images.js

@@ -30,7 +30,7 @@ const Started = Schema.Struct({ id: Schema.String });
 /** `sd3.5-*` ids share the `sd3` endpoint and select the model with a form field. */
 const endpoint = (model) => (model.startsWith("sd3") ? "sd3" : model);
 const RESERVED_FORM_FIELDS = new Set(["image", "prompt", "mode", "model"]);
-const form = Effect.fn("StabilityImages.form")(function* (identity, fields, native, source) {
+const form = Effect.fnUntraced(function* (identity, fields, native, source) {
     if ((source?.length ?? 0) > 1)
         return yield* identity.unsupported("media.images", `${identity.name} takes one source image`);
     const body = new FormData();

package/dist/protocols/utils/bedrock-media.js

@@ -61,7 +61,7 @@ function documentName(filename, names) {
     names.add(name);
     return name;
 }
-const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
+const mediaBase64 = Effect.fnUntraced(function* (part) {
     const media = yield* ProviderShared.requireInlineMedia("Bedrock Converse", part.media);
     const bytes = yield* Effect.fromResult(Encoding.decodeBase64(media.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest("Bedrock Converse media data must be valid base64", cause)));
     return Encoding.encodeBase64(bytes);
@@ -71,7 +71,7 @@ const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
 // document block. Image MIME types not in `IMAGE_FORMATS` (e.g. `image/svg+xml`)
 // get an image-specific error so the caller knows it's a format-support issue,
 // not a kind-detection issue.
-export const lower = Effect.fn("BedrockMedia.lower")(function* (part, documentNames) {
+export const lower = Effect.fnUntraced(function* (part, documentNames) {
     const mime = part.media.mediaType.toLowerCase();
     const imageFormat = IMAGE_FORMATS[mime];
     if (imageFormat) {

package/dist/protocols/utils/gateway-protocol.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import { Protocol } from "../../route/protocol.js";
+import { type AIError, type LLMRequest } from "../../schema/index.js";
+interface ParserState<Inner> {
+    readonly inner: Inner;
+    readonly gateway?: Record<string, unknown>;
+}
+export declare function gatewayProtocol<Body, Event, State>(protocol: Protocol<Body, string, Event, State>, input: {
+    readonly id: string;
+    readonly prepare: (request: LLMRequest) => Effect.Effect<{
+        readonly request: LLMRequest;
+        readonly body: Record<string, unknown>;
+    }, AIError>;
+}): Protocol<{
+    readonly [x: string]: unknown;
+}, string, Event, ParserState<State>>;
+export {};