@opencode/ai 0.0.0-dev-20141 → 0.0.0-dev-20142

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

@@ -725,6 +725,9 @@ export declare const lowerTool: (protocolName: string, tool: ToolDefinition) =>
     };
     strict: boolean;
 }, AIError, never>;
+export declare const lowerTools: (tools: ReadonlyArray<ToolDefinition>, adapter: ProviderAdapter) => Effect.Effect<{
+    readonly type: string;
+}[], AIError, never>;
 export declare const lowerToolChoice: (protocolName: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>) => Effect.Effect<"required" | "auto" | "none" | {
     type: "function";
     name: string;

package/dist/protocols/open-responses.js

@@ -292,6 +292,7 @@ export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protoco
         strict: false,
     };
 });
+export const lowerTools = (tools, adapter) => Effect.forEach(tools, (tool) => tool.native !== undefined && adapter.nativeTool ? adapter.nativeTool(tool.native) : lowerTool(adapter.name, tool));
 export const lowerToolChoice = (protocolName, toolChoice) => ProviderShared.matchToolChoice(protocolName, toolChoice, {
     auto: () => "auto",
     none: () => "none",
@@ -605,11 +606,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
     return {
         ...(yield* lowerConversation(projected.request, adapter)),
         ...lowerGeneration(request),
-        tools: projected.tools.length === 0
-            ? undefined
-            : yield* Effect.forEach(projected.tools, (tool) => tool.native !== undefined && adapter.nativeTool
-                ? adapter.nativeTool(tool.native)
-                : lowerTool(adapter.name, tool)),
+        tools: projected.tools.length === 0 ? undefined : yield* lowerTools(projected.tools, adapter),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

package/dist/protocols/openai-responses.js

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
 import { HttpTransport } from "../route/transport/index.js";
-import { LLMRequest, mergeJsonRecords } from "../schema/index.js";
+import { LLMRequest } from "../schema/index.js";
 import { resolveEffortUpdates } from "../effort-updates.js";
 import { OpenResponses } from "./open-responses.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -105,9 +105,6 @@ export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compactio
 const CheckpointBody = Schema.Struct({
     ...OpenAIResponsesBody.fields,
     input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
-    store: Schema.Literal(false),
-    prompt_cache_retention: optionalNull(Schema.String),
-    prompt_cache_options: optionalNull(Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) })),
 });
 const adapter = {
     id: ADAPTER,
@@ -154,6 +151,7 @@ const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (to
         tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) => OpenResponses.lowerTool(NAME, leaf)),
     };
 });
+const lowerTools = (request) => Effect.forEach(request.tools, lowerToolEntry);
 const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto",
     none: () => "none",
@@ -171,7 +169,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
         ...(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 })),
-        tools: request.tools.length === 0 ? undefined : yield* Effect.forEach(request.tools, lowerToolEntry),
+        tools: request.tools.length === 0 ? undefined : yield* lowerTools(request),
         tool_choice: request.tools.length === 0
             ? undefined
             : (OpenResponses.allowedToolChoice(request) ??
@@ -181,25 +179,19 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
 const checkpointBody = {
     schema: CheckpointBody,
     from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request) {
-        const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }));
         const overlay = request.http?.body;
         // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
         if (overlay?.input !== undefined ||
             overlay?.previous_response_id !== undefined ||
             overlay?.conversation !== undefined)
             return yield* ProviderShared.invalidRequest("Trigger compaction requires complete canonical history, not an input or continuation override");
-        return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
-            ...mergeJsonRecords(native, overlay),
+        if (overlay?.stream !== undefined && overlay.stream !== true)
+            return yield* ProviderShared.invalidRequest("Trigger compaction requires a streamed response");
+        const native = yield* fromRequest(request);
+        return {
+            ...native,
             input: [...native.input, { type: "compaction_trigger" }],
-            stream: true,
-            store: false,
-            parallel_tool_calls: true,
-            tool_choice: undefined,
-            context_management: undefined,
-            text: undefined,
-            max_output_tokens: undefined,
-            max_tool_calls: undefined,
-        });
+        };
     }),
 };
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
@@ -270,7 +262,10 @@ export const transport = channelTransport({
     headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
 });
 export const route = Route.make({
-    compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
+    compact: {
+        endpoint: ResponsesCompaction.make(adapter, lowerTools),
+        trigger: ResponsesCheckpoint.make(checkpointBody),
+    },
     id: ADAPTER,
     provider: "openai",
     providerMetadataKey: "openai",

package/dist/protocols/utils/responses-checkpoint.js

@@ -1,7 +1,7 @@
 import { Effect, Schema, Stream } from "effect";
 import { Route } from "../../route/client.js";
 import { Protocol } from "../../route/protocol.js";
-import { CompactionCheckpointResponse, HttpOptions, LLMEvent, LLMRequest } from "../../schema/index.js";
+import { CompactionCheckpointResponse, LLMEvent, LLMRequest } from "../../schema/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { ProviderShared } from "../shared.js";
 const onOutputItem = Effect.fn("ResponsesCheckpoint.onOutputItem")(function* (state, input) {
@@ -94,12 +94,8 @@ export const make = (body) => Effect.fn("ResponsesCheckpoint.execute")(function*
         transport: source.transport,
     });
     const native = yield* body.from(request);
-    // The body builder already applied and validated overlays. Do not let transport reapply them.
-    const preparedRequest = LLMRequest.update(request, {
-        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-    });
-    const prepared = yield* route.prepareTransport(native, preparedRequest, options);
-    yield* route.streamPrepared(prepared, preparedRequest, { http: executor }, options).pipe(Stream.runDrain);
+    const prepared = yield* route.prepareTransport(native, request, options);
+    yield* route.streamPrepared(prepared, request, { http: executor }, options).pipe(Stream.runDrain);
     if (!result)
         return yield* ProviderShared.eventError(source.id, "Compaction response ended without a checkpoint");
     return result;

package/dist/protocols/utils/responses-compaction.d.ts

@@ -1,4 +1,6 @@
+import { Effect } from "effect";
+import { AIError, LLMRequest } from "../../schema/index.js";
 import type { CompactOperation } from "../../route/client.js";
 import { OpenResponses } from "../open-responses.js";
-export declare const make: (adapter: OpenResponses.ProviderAdapter) => CompactOperation;
+export declare const make: (adapter: OpenResponses.ProviderAdapter, lowerTools: (request: LLMRequest) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, AIError>) => CompactOperation;
 export * as ResponsesCompaction from "./responses-compaction.js";

package/dist/protocols/utils/responses-compaction.js

@@ -7,12 +7,18 @@ import { HttpTransport } from "../../route/transport/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { JsonObject, optionalNull, ProviderShared } from "../shared.js";
 import { Media } from "../../media.js";
+// /compact has a smaller wire contract than /responses; keep the request controls it accepts.
 const Body = Schema.Struct({
     model: Schema.String,
     input: Schema.Array(Schema.Unknown),
     instructions: optionalNull(Schema.String),
     previous_response_id: optionalNull(Schema.String),
     service_tier: optionalNull(Schema.String),
+    reasoning: Schema.optional(JsonObject),
+    text: Schema.optional(JsonObject),
+    include: OpenResponses.coreFields.include,
+    parallel_tool_calls: OpenResponses.coreFields.parallel_tool_calls,
+    tools: Schema.optional(Schema.Array(JsonObject)),
     prompt_cache_key: optionalNull(Schema.String),
     prompt_cache_retention: optionalNull(Schema.String),
     prompt_cache_options: optionalNull(Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) })),
@@ -54,14 +60,21 @@ const Response = Schema.Struct({
     ])),
     usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
 });
-export const make = (adapter) => Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
+export const make = (adapter, lowerTools) => Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
     const route = request.model.route;
     // The standalone compaction endpoint rejects histories containing configuration updates.
     const native = yield* OpenResponses.lowerConversation(stripEffortUpdates(request), adapter);
+    const generation = OpenResponses.lowerGeneration(request);
+    const tools = request.tools.length === 0 ? undefined : yield* lowerTools(request);
     const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
         ...native,
-        service_tier: request.providerOptions?.serviceTier,
-        prompt_cache_key: ProviderShared.promptCacheKey(request),
+        service_tier: generation.service_tier,
+        reasoning: generation.reasoning,
+        text: generation.text,
+        include: generation.include,
+        parallel_tool_calls: generation.parallel_tool_calls,
+        tools,
+        prompt_cache_key: generation.prompt_cache_key,
     }, request.http?.body));
     const url = Endpoint.render(route.endpoint, { request, body: native });
     url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`;

package/dist/protocols/xai-responses.js

@@ -77,5 +77,5 @@ export const protocol = Protocol.make({
         terminal: OpenResponses.terminal,
     },
 });
-export const compact = ResponsesCompaction.make(adapter);
+export const compact = ResponsesCompaction.make(adapter, (request) => OpenResponses.lowerTools(ProviderShared.flattenTools(request.tools), adapter));
 export * as XAIResponses from "./xai-responses.js";

package/dist/providers/openai-options.d.ts

@@ -10,17 +10,11 @@ export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
     readonly [key: string]: unknown;
 };
 export type OpenAIProviderOptionsInput = OpenAIOptionsInput;
-export declare const gpt5DefaultOptions: (modelID: string, options?: {
-    readonly textVerbosity?: boolean;
-}) => ProviderOptions | undefined;
-export declare const openAIDefaultOptions: (modelID: string, options?: {
-    readonly textVerbosity?: boolean;
-}) => ProviderOptions | undefined;
+export declare const gpt5DefaultOptions: (modelID: string) => ProviderOptions | undefined;
+export declare const openAIDefaultOptions: (modelID: string) => ProviderOptions | undefined;
 export declare const withOpenAIOptions: <Options extends {
     readonly providerOptions?: OpenAIProviderOptionsInput;
-}>(modelID: string, options: Options, defaults?: {
-    readonly textVerbosity?: boolean;
-}) => Omit<Options, "providerOptions"> & {
+}>(modelID: string, options: Options) => Omit<Options, "providerOptions"> & {
     readonly providerOptions?: ProviderOptions;
 };
 export * as OpenAIProviderOptions from "./openai-options.js";

package/dist/providers/openai-options.js

@@ -13,7 +13,7 @@ const openAIProviderOptions = (options) => {
         return undefined;
     return result;
 };
-export const gpt5DefaultOptions = (modelID, options = {}) => {
+export const gpt5DefaultOptions = (modelID) => {
     const id = modelID.toLowerCase();
     if (!id.includes("gpt-5") || id.includes("gpt-5-chat") || id.includes("gpt-5-pro"))
         return undefined;
@@ -26,16 +26,13 @@ export const gpt5DefaultOptions = (modelID, options = {}) => {
         // this, callers using the default model facade get reasoning summaries
         // they cannot replay statelessly.
         include: ["reasoning.encrypted_content"],
-        textVerbosity: options.textVerbosity === true && id.includes("gpt-5.") && !id.includes("codex") && !id.includes("-chat")
-            ? "low"
-            : undefined,
     });
 };
-export const openAIDefaultOptions = (modelID, options = {}) => mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID, options));
-export const withOpenAIOptions = (modelID, options, defaults = {}) => {
+export const openAIDefaultOptions = (modelID) => mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID));
+export const withOpenAIOptions = (modelID, options) => {
     return {
         ...options,
-        providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID, defaults), options.providerOptions),
+        providerOptions: mergeProviderOptions(openAIDefaultOptions(modelID), options.providerOptions),
     };
 };
 export * as OpenAIProviderOptions from "./openai-options.js";

package/dist/providers/openai.js

@@ -41,7 +41,7 @@ export const configure = (input = {}) => {
     const chatRoute = configuredRoute(OpenAIChat.route, input);
     const modelDefaults = defaults(input);
     const responses = (id) => responsesRoute
-        .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+        .with(withOpenAIOptions(id, modelDefaults))
         .model({ id });
     const chat = (id) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({
         id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20141",
+  "version": "0.0.0-dev-20142",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20141",
+    "@opencode/http-recorder": "0.0.0-dev-20142",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20141",
+    "@opencode/schema": "0.0.0-dev-20142",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"