@opencode-ai/ai 0.0.0-beta-17595 → 0.0.0-beta-17727

package/dist/protocols/open-responses.js

@@ -63,8 +63,11 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
 ]);
 export const InputItem = Schema.Union([
     Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
+    Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
     Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
     Schema.Struct({
+        type: Schema.tag("message"),
+        id: Schema.optionalKey(Schema.String),
         role: Schema.tag("assistant"),
         content: Schema.Array(OpenResponsesOutputText),
         phase: Schema.optionalKey(MessagePhase),
@@ -73,6 +76,7 @@ export const InputItem = Schema.Union([
     OpenResponsesItemReference,
     Schema.Struct({
         type: Schema.tag("function_call"),
+        id: Schema.optionalKey(Schema.String),
         call_id: Schema.String,
         name: Schema.String,
         arguments: Schema.String,
@@ -93,6 +97,11 @@ export const Tool = Schema.Struct({
 export const ToolChoice = Schema.Union([
     Schema.Literals(["auto", "none", "required"]),
     Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
+    Schema.Struct({
+        type: Schema.tag("allowed_tools"),
+        mode: Schema.Literals(["auto", "none", "required"]),
+        tools: Schema.Array(Schema.Struct({ type: Schema.tag("function"), name: Schema.String })),
+    }),
 ]);
 // Fields shared between the HTTP body and the WebSocket `response.create`
 // message. The HTTP body adds `stream: true`; the WebSocket message adds
@@ -105,6 +114,13 @@ export const coreFields = {
     tools: optionalArray(Tool),
     tool_choice: Schema.optional(ToolChoice),
     store: Schema.optional(Schema.Boolean),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    safety_identifier: Schema.optional(Schema.String),
+    stream_options: Schema.optional(Schema.Struct({
+        include_obfuscation: Schema.optional(Schema.Boolean),
+    })),
+    top_logprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
+    truncation: Schema.optional(OpenResponsesOptions.TruncationSchema),
     service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
     prompt_cache_key: Schema.optional(Schema.String),
     include: optionalArray(OpenResponsesOptions.ResponseIncludableSchema),
@@ -116,8 +132,12 @@ export const coreFields = {
         verbosity: Schema.optional(OpenResponsesOptions.TextVerbositySchema),
     })),
     max_output_tokens: Schema.optional(Schema.Number),
+    max_tool_calls: Schema.optional(Schema.Int),
+    parallel_tool_calls: Schema.optional(Schema.Boolean),
     temperature: Schema.optional(Schema.Number),
     top_p: Schema.optional(Schema.Number),
+    presence_penalty: Schema.optional(Schema.Number),
+    frequency_penalty: Schema.optional(Schema.Number),
 };
 const OpenResponsesBody = Schema.Struct({
     ...coreFields,
@@ -193,6 +213,19 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     status_code: Schema.optional(Schema.Unknown),
     headers: Schema.optional(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const RefusalEvent = Schema.Union([
+    Schema.Struct({
+        type: Schema.tag("response.refusal.delta"),
+        item_id: Schema.String,
+        delta: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.tag("response.refusal.done"),
+        item_id: Schema.String,
+        refusal: Schema.String,
+    }),
+]);
+const isRefusalEvent = Schema.is(RefusalEvent);
 const BASE = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
@@ -205,7 +238,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         name: tool.name,
         description: tool.description,
         parameters: ToolSchemaProjection.responses(inputSchema),
-        // TODO: Read this from Responses tool options so direct LLM callers can opt into strict schemas.
+        // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
 });
@@ -215,31 +248,39 @@ export const lowerToolChoice = (protocolName, toolChoice) => ProviderShared.matc
     required: () => "required",
     tool: (toolName) => ({ type: "function", name: toolName }),
 });
-const lowerToolCall = (part) => ({
-    type: "function_call",
-    call_id: part.id,
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-});
+const itemID = (providerMetadata, providerMetadataKey) => {
+    const metadata = providerMetadata?.[providerMetadataKey];
+    return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
+        ? metadata.itemId
+        : undefined;
+};
+const lowerToolCall = (part, providerMetadataKey) => {
+    const id = itemID(part.providerMetadata, providerMetadataKey);
+    return {
+        type: "function_call",
+        ...(id ? { id } : {}),
+        call_id: part.id,
+        name: part.name,
+        arguments: ProviderShared.encodeJson(part.input),
+    };
+};
 const lowerReasoning = (part, providerMetadataKey) => {
     const metadata = part.providerMetadata?.[providerMetadataKey];
-    if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
+    const id = itemID(part.providerMetadata, providerMetadataKey);
+    if (!ProviderShared.isRecord(metadata) || !id)
         return undefined;
     const encryptedContent = typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
         ? metadata.reasoningEncryptedContent
         : undefined;
     return {
         type: "reasoning",
-        id: metadata.itemId,
+        id,
         summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
         encrypted_content: encryptedContent,
     };
 };
 const hostedToolItemID = (part, providerMetadataKey) => {
-    const metadata = part.providerMetadata?.[providerMetadataKey];
-    return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-        ? metadata.itemId
-        : undefined;
+    return itemID(part.providerMetadata, providerMetadataKey);
 };
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, request, extension) {
     const media = ProviderShared.normalizeMedia(part);
@@ -285,15 +326,10 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
     const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses";
     for (const message of request.messages) {
         if (message.role === "system") {
-            const part = yield* ProviderShared.wrappedSystemUpdate(extension.name, message);
-            const previous = input.at(-1);
-            if (previous && "role" in previous && previous.role === "user")
-                input[input.length - 1] = {
-                    role: "user",
-                    content: [...previous.content, { type: "input_text", text: part.text }],
-                };
-            else
-                input.push({ role: "user", content: [{ type: "input_text", text: part.text }] });
+            input.push({
+                role: "developer",
+                content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(extension.name, message)),
+            });
             continue;
         }
         if (message.role === "user") {
@@ -313,15 +349,18 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     return;
                 const groups = content.reduce((groups, part) => {
                     const metadata = part.providerMetadata?.[providerMetadataKey];
+                    const id = itemID(part.providerMetadata, providerMetadataKey);
                     const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined;
                     const group = groups.at(-1);
-                    if (group && group.phase === phase)
+                    if (group && group.id === id && group.phase === phase)
                         group.parts.push(part);
                     else
-                        groups.push({ phase, parts: [part] });
+                        groups.push({ id, phase, parts: [part] });
                     return groups;
                 }, []);
                 input.push(...groups.map((group) => ({
+                    type: "message",
+                    ...(group.id === undefined ? {} : { id: group.id }),
                     role: "assistant",
                     content: group.parts.map((part) => ({ type: "output_text", text: part.text })),
                     ...(group.phase === undefined ? {} : { phase: group.phase }),
@@ -351,20 +390,15 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                             existing.encrypted_content = reasoning.encrypted_content;
                         continue;
                     }
-                    const replay = {
-                        type: reasoning.type,
-                        summary: reasoning.summary,
-                        encrypted_content: reasoning.encrypted_content,
-                    };
-                    reasoningItems[reasoning.id] = replay;
-                    input.push(replay);
+                    reasoningItems[reasoning.id] = reasoning;
+                    input.push(reasoning);
                     continue;
                 }
                 if (part.type === "tool-call") {
                     flushText();
                     if (part.providerExecuted === true)
                         continue;
-                    input.push(lowerToolCall(part));
+                    input.push(lowerToolCall(part, providerMetadataKey));
                     continue;
                 }
                 if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -415,6 +449,12 @@ const lowerOptions = (request) => {
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
         ...(options.store !== undefined ? { store: options.store } : {}),
+        ...(options.metadata ? { metadata: options.metadata } : {}),
+        ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
+        ...(options.streamOptions?.includeObfuscation !== undefined
+            ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
+            : {}),
+        ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
         ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
         ...(options.include ? { include: options.include } : {}),
         ...(options.reasoningEffort || options.reasoningSummary
@@ -422,6 +462,19 @@ const lowerOptions = (request) => {
             : {}),
         ...(options.textVerbosity ? { text: { verbosity: options.textVerbosity } } : {}),
         ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
+        ...(options.maxToolCalls !== undefined ? { max_tool_calls: options.maxToolCalls } : {}),
+        ...(options.parallelToolCalls !== undefined ? { parallel_tool_calls: options.parallelToolCalls } : {}),
+        ...(options.truncation ? { truncation: options.truncation } : {}),
+    };
+};
+const allowedToolChoice = (request) => {
+    const allowed = OpenResponsesOptions.resolve(request).allowedTools;
+    if (!allowed)
+        return undefined;
+    return {
+        type: "allowed_tools",
+        mode: allowed.mode,
+        tools: allowed.toolNames.map((name) => ({ type: "function", name })),
     };
 };
 export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWithExtension")(function* (request, extension) {
@@ -433,11 +486,14 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
         tools: request.tools.length === 0
             ? undefined
             : yield* Effect.forEach(request.tools, (tool) => lowerTool(extension.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
-        tool_choice: request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined,
+        tool_choice: allowedToolChoice(request) ??
+            (request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined),
         stream: true,
         max_output_tokens: generation?.maxTokens,
         temperature: generation?.temperature,
         top_p: generation?.topP,
+        presence_penalty: generation?.presencePenalty,
+        frequency_penalty: generation?.frequencyPenalty,
         ...lowerOptions(request),
     };
 });
@@ -500,7 +556,7 @@ const onOutputTextDelta = (state, event, id) => {
         return [state, NO_EVENTS];
     const events = [];
     const phase = state.messagePhases[id];
-    const metadata = phase === undefined ? undefined : providerMetadata(state, { phase });
+    const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) });
     const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata);
     return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events];
 };
@@ -684,7 +740,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         return [
             {
                 ...state,
-                lifecycle: Lifecycle.textEnd(state.lifecycle, events, item.id, phase === undefined ? undefined : providerMetadata(state, { phase })),
+                lifecycle: Lifecycle.textEnd(state.lifecycle, events, item.id, providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })),
                 messageItems,
                 messagePhases,
             },
@@ -696,7 +752,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
             return [state, NO_EVENTS];
         const tools = state.tools[item.id]
             ? state.tools
-            : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name });
+            : ToolStream.start(state.tools, item.id, {
+                id: item.call_id,
+                name: item.name,
+                providerMetadata: providerMetadata(state, { itemId: item.id }),
+            });
         const result = item.arguments === undefined
             ? yield* ToolStream.finish(state.id, tools, item.id)
             : yield* ToolStream.finishWithInput(state.id, tools, item.id, item.arguments);
@@ -739,11 +799,17 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     }
     return [state, NO_EVENTS];
 });
-const onResponseFinish = (state, event) => {
-    const events = [];
+const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
+    // Some compatible providers omit output_item.done even after completing the response.
+    const pending = event.type === "response.completed"
+        ? yield* ToolStream.finishAll(state.id, state.tools)
+        : { tools: state.tools, events: NO_EVENTS };
+    const events = [...pending.events];
+    const hasFunctionCall = pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
+        state.hasFunctionCall;
     const lifecycle = Lifecycle.finish(state.lifecycle, events, {
         reason: {
-            normalized: mapFinishReason(event, state.hasFunctionCall),
+            normalized: mapFinishReason(event, hasFunctionCall),
             raw: event.response?.incomplete_details?.reason,
         },
         usage: mapUsage(event.response?.usage, state.providerMetadataKey),
@@ -754,8 +820,8 @@ const onResponseFinish = (state, event) => {
             })
             : undefined,
     });
-    return [{ ...state, lifecycle }, events];
-};
+    return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events];
+});
 // Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
 // the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
@@ -792,6 +858,13 @@ export const step = (state, event) => {
             ? onOutputTextDelta(state, event, event.item_id)
             : onOutputTextDone(state, event, event.item_id));
     }
+    if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
+        if (!isRefusalEvent(event))
+            return ProviderShared.eventError(state.id, `${event.type} is malformed`);
+        return Effect.succeed(event.type === "response.refusal.delta"
+            ? onOutputTextDelta(state, event, event.item_id)
+            : onOutputTextDone(state, { ...event, text: event.refusal }, event.item_id));
+    }
     if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
         if (!event.item_id)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
@@ -823,7 +896,7 @@ export const step = (state, event) => {
         return onOutputItemDone(state, event);
     }
     if (event.type === "response.completed" || event.type === "response.incomplete")
-        return Effect.succeed(onResponseFinish(state, event));
+        return onResponseFinish(state, event);
     if (event.type === "response.failed")
         return providerError(state, event, `${state.name} response failed`);
     if (event.type === "error")

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

@@ -95,7 +95,7 @@ export declare const bodyFields: {
     }>>;
     store: Schema.optional<Schema.Boolean>;
     prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.String>;
+    reasoning_effort: Schema.optional<Schema.declare<import("./utils/open-responses-options.js").ReasoningEffort, import("./utils/open-responses-options.js").ReasoningEffort>>;
     max_completion_tokens: Schema.optional<Schema.Number>;
     max_tokens: Schema.optional<Schema.Number>;
     temperature: Schema.optional<Schema.Number>;
@@ -189,7 +189,7 @@ declare const OpenAIChatBody: Schema.Struct<{
     }>>;
     store: Schema.optional<Schema.Boolean>;
     prompt_cache_key: Schema.optional<Schema.String>;
-    reasoning_effort: Schema.optional<Schema.String>;
+    reasoning_effort: Schema.optional<Schema.declare<import("./utils/open-responses-options.js").ReasoningEffort, import("./utils/open-responses-options.js").ReasoningEffort>>;
     max_completion_tokens: Schema.optional<Schema.Number>;
     max_tokens: Schema.optional<Schema.Number>;
     temperature: Schema.optional<Schema.Number>;
@@ -204,6 +204,7 @@ export declare const OpenAIChatEvent: Schema.Struct<{
     readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly refusal: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning_content: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning: Schema.optional<Schema.NullOr<Schema.String>>;
             readonly reasoning_text: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -263,7 +264,7 @@ interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
 }
 export declare const fromRequest: (request: LLMRequest, options?: LoweringOptions | undefined) => Effect.Effect<{
-    reasoning_effort?: string | undefined;
+    reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     prompt_cache_key?: string | undefined;
     store?: boolean | undefined;
     temperature: number | undefined;
@@ -347,7 +348,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    tool_choice: "required" | "none" | "auto" | {
+    tool_choice: "required" | "auto" | "none" | {
         type: "function";
         function: {
             name: string;
@@ -358,7 +359,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
         include_usage: boolean;
     };
 } | {
-    reasoning_effort?: string | undefined;
+    reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     prompt_cache_key?: string | undefined;
     store?: boolean | undefined;
     temperature: number | undefined;
@@ -442,7 +443,7 @@ export declare const fromRequest: (request: LLMRequest, options?: LoweringOption
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
-    tool_choice: "required" | "none" | "auto" | {
+    tool_choice: "required" | "auto" | "none" | {
         type: "function";
         function: {
             name: string;
@@ -521,7 +522,6 @@ export declare const protocol: Protocol<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -538,9 +538,10 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -552,7 +553,7 @@ export declare const protocol: Protocol<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, string, {
@@ -584,6 +585,7 @@ export declare const protocol: Protocol<{
             readonly reasoning_content?: string | null | undefined;
             readonly reasoning_text?: string | null | undefined;
             readonly content?: string | null | undefined;
+            readonly refusal?: string | null | undefined;
             readonly tool_calls?: readonly {
                 readonly function?: {
                     readonly name?: string | null | undefined;
@@ -660,7 +662,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -677,9 +678,10 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -691,7 +693,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, string>;
@@ -757,7 +759,6 @@ export declare const route: Route<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -774,9 +775,10 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -788,7 +790,7 @@ export declare const route: Route<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, HttpTransport.HttpPrepared<string>>;

package/dist/protocols/openai-chat.js

@@ -13,7 +13,7 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "openai-chat";
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"]);
+const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"]);
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/chat/completions";
 // =============================================================================
@@ -144,6 +144,7 @@ const OpenAIChatToolCallDelta = Schema.Struct({
 });
 const OpenAIChatDelta = Schema.StructWithRest(Schema.Struct({
     content: optionalNull(Schema.String),
+    refusal: optionalNull(Schema.String),
     reasoning_content: optionalNull(Schema.String),
     reasoning: optionalNull(Schema.String),
     reasoning_text: optionalNull(Schema.String),
@@ -568,6 +569,7 @@ const step = (state, event) => Effect.gen(function* () {
     let lifecycle = state.lifecycle;
     const reasoning = reasoningDelta(delta, state.reasoningField);
     const hasLateContent = Boolean(delta?.content) ||
+        Boolean(delta?.refusal) ||
         reasoning !== undefined ||
         (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
         toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments));
@@ -587,13 +589,17 @@ const step = (state, event) => Effect.gen(function* () {
         lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata);
     else if (reasoningDetailsObserved &&
         !lifecycle.reasoning.has("reasoning-0") &&
-        (Boolean(delta?.content) || toolDeltas.length > 0))
+        (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0))
         lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata);
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0");
     if (delta?.content) {
         lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content);
     }
+    if (delta?.refusal) {
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
+        lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal);
+    }
     // Compatible providers may omit indexes. Prefer durable identity, then use
     // batch position for parallel deltas or the latest call for sparse chunks.
     for (const [position, tool] of toolDeltas.entries()) {

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

@@ -69,7 +69,6 @@ export declare const route: Route<{
         } | undefined;
     })[];
     readonly stream: true;
-    readonly stop?: readonly string[] | undefined;
     readonly max_completion_tokens?: number | undefined;
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
@@ -86,9 +85,10 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
     }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly function: {
             readonly name: string;
@@ -100,7 +100,7 @@ export declare const route: Route<{
         readonly include_usage: boolean;
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly reasoning_effort?: string | undefined;
+    readonly reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>;

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

@@ -20,6 +20,9 @@ export declare const route: Route<{
     } | {
         readonly role: "system";
         readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
     } | {
         readonly role: "user";
         readonly content: readonly ({
@@ -35,17 +38,20 @@ export declare const route: Route<{
             readonly text: string;
         })[];
     } | {
+        readonly type: "message";
         readonly content: readonly {
             readonly type: "output_text";
             readonly text: string;
         }[];
         readonly role: "assistant";
+        readonly id?: string | undefined;
         readonly phase?: "commentary" | "final_answer" | undefined;
     } | {
         readonly type: "function_call";
-        readonly call_id: string;
         readonly name: string;
         readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
     } | {
         readonly type: "function_call_output";
         readonly call_id: string;
@@ -64,10 +70,13 @@ export declare const route: Route<{
     })[];
     readonly model: string;
     readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: string | undefined;
+        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly {
         readonly type: "function";
@@ -79,18 +88,35 @@ export declare const route: Route<{
         readonly strict?: boolean | undefined;
     }[] | undefined;
     readonly text?: {
-        readonly verbosity?: "low" | "medium" | "high" | undefined;
+        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
-    readonly tool_choice?: "required" | "none" | "auto" | {
+    readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
     } | undefined;
     readonly top_p?: number | undefined;
-    readonly include?: readonly ("file_search_call.results" | "web_search_call.results" | "web_search_call.action.sources" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "code_interpreter_call.outputs" | "reasoning.encrypted_content" | "message.output_text.logprobs")[] | undefined;
     readonly store?: boolean | undefined;
+    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
     readonly prompt_cache_key?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
     readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
     readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>;
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";