@purista/harness-openai 1.2.4 → 1.2.6

package/README.md

@@ -43,6 +43,14 @@ the adapter drops `reasoning_effort` and emits a warning instead of sending a
 request that OpenAI rejects. Use `api: 'responses'` when you need reasoning
 effort and tool calls together.
 
+On the Responses API, tool-call responses carry the turn's raw output items
+(including reasoning items) as `providerItems`. The harness agent loop passes
+them back on the follow-up round and the adapter echoes them verbatim, as
+OpenAI recommends for reasoning models with manually managed conversation
+state. For stateless requests (`store: false`), additionally set
+`providerOptions: { store: false, include: ['reasoning.encrypted_content'] }`
+so the encrypted reasoning content rides along in the replayed items.
+
 ## Package Format
 
 This package is ESM-only and ships compiled JavaScript plus TypeScript

package/dist/index.js

@@ -107,9 +107,11 @@ class OpenAiModelProvider extends BaseModelProvider {
             const response = await createResponse(this.client, req, false);
             const content = extractResponsesText(response);
             const toolCalls = extractResponsesToolCalls(response, req, 'object');
+            const providerItems = toResponsesProviderItems(response.output, toolCalls);
             return {
                 object: parseJson(content || '{}', req, 'object'),
                 ...(toolCalls ? { toolCalls } : {}),
+                ...(providerItems ? { providerItems } : {}),
                 usage: toResponsesUsage(response.usage),
                 finishReason: toResponsesFinishReason(response),
                 raw: response
@@ -251,7 +253,6 @@ async function createResponse(client, req, stream) {
         model: req.model,
         input: toResponsesInput(req.messages),
         stream,
-        ...(stream ? { stream_options: { include_usage: true } } : {}),
         tools: toResponsesTools(req.tools),
         temperature: req.call?.temperature ?? req.defaults?.temperature,
         max_output_tokens: req.call?.maxTokens ?? req.defaults?.maxTokens,
@@ -369,6 +370,13 @@ function toResponsesInput(messages) {
             });
             continue;
         }
+        if (message.role === 'assistant' && message.providerItems?.providerId === 'openai' && message.providerItems.items.length > 0) {
+            // Echo the captured turn (reasoning, message, and function_call items)
+            // verbatim, as the Responses API expects for manually managed state.
+            // Foreign provider items fall through to provider-neutral reconstruction.
+            input.push(...message.providerItems.items);
+            continue;
+        }
         if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
             if (typeof message.content === 'string' && message.content.length > 0) {
                 input.push({
@@ -378,9 +386,11 @@ function toResponsesInput(messages) {
                 });
             }
             for (const call of message.toolCalls) {
+                // The Responses API only accepts an `fc_…` item id on `function_call`
+                // input items; the harness tool-call id is the `call_…` value, so the
+                // optional item id is omitted, mirroring `function_call_output`.
                 input.push({
                     type: 'function_call',
-                    id: call.id,
                     call_id: call.id,
                     name: call.name,
                     arguments: JSON.stringify(call.arguments)
@@ -446,18 +456,35 @@ function toResponsesTools(tools) {
 }
 function mapResponsesTextResponse(response, req) {
     const toolCalls = extractResponsesToolCalls(response, req, 'text');
+    const providerItems = toResponsesProviderItems(response.output, toolCalls);
     return {
         content: extractResponsesText(response),
         ...(toolCalls ? { toolCalls } : {}),
+        ...(providerItems ? { providerItems } : {}),
         usage: toResponsesUsage(response.usage),
         finishReason: toResponsesFinishReason(response),
         raw: response
     };
 }
+/**
+ * Captures the turn's raw Responses output items on tool-call responses so
+ * they can be replayed verbatim on the follow-up round. OpenAI requires
+ * reasoning items returned with tool calls to be passed back with the tool
+ * outputs for reasoning models; echoing `response.output` unchanged is the
+ * pattern documented in the Responses migration guide.
+ */
+function toResponsesProviderItems(output, toolCalls) {
+    if (!toolCalls || toolCalls.length === 0)
+        return undefined;
+    if (!Array.isArray(output) || output.length === 0)
+        return undefined;
+    return { providerId: 'openai', items: output };
+}
 async function* streamResponsesText(client, req) {
     const stream = await createResponse(client, req, true);
     let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     let finishReason = 'stop';
+    let completedOutput;
     const toolState = new Map();
     for await (const event of stream) {
         req.signal.throwIfAborted();
@@ -476,21 +503,25 @@ async function* streamResponsesText(client, req) {
         else if (event.type === 'response.completed') {
             usage = toResponsesUsage(event.response?.usage);
             finishReason = toResponsesFinishReason(event.response);
+            completedOutput = event.response?.output;
         }
         else if (event.type === 'response.failed' || event.type === 'response.incomplete') {
             finishReason = 'error';
         }
     }
-    for (const call of finalizeResponsesStreamToolCalls(toolState, req, 'textStream')) {
+    const toolCalls = finalizeResponsesStreamToolCalls(toolState, req, 'textStream');
+    for (const call of toolCalls) {
         yield { kind: 'tool_call', call };
     }
-    yield { kind: 'finish', usage, finishReason };
+    const providerItems = toResponsesProviderItems(completedOutput, toolCalls);
+    yield { kind: 'finish', usage, finishReason, ...(providerItems ? { providerItems } : {}) };
 }
 async function* streamResponsesObject(client, req) {
     const stream = await createResponse(client, req, true);
     let partial = '';
     let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     let finishReason = 'stop';
+    let completedOutput;
     const toolState = new Map();
     for await (const event of stream) {
         req.signal.throwIfAborted();
@@ -510,16 +541,19 @@ async function* streamResponsesObject(client, req) {
         else if (event.type === 'response.completed') {
             usage = toResponsesUsage(event.response?.usage);
             finishReason = toResponsesFinishReason(event.response);
+            completedOutput = event.response?.output;
         }
         else if (event.type === 'response.failed' || event.type === 'response.incomplete') {
             finishReason = 'error';
         }
     }
-    for (const call of finalizeResponsesStreamToolCalls(toolState, req, 'objectStream')) {
+    const toolCalls = finalizeResponsesStreamToolCalls(toolState, req, 'objectStream');
+    for (const call of toolCalls) {
         yield { kind: 'tool_call', call };
     }
     const object = parseJson(partial || '{}', req, 'objectStream');
-    yield { kind: 'finish', object, usage, finishReason };
+    const providerItems = toResponsesProviderItems(completedOutput, toolCalls);
+    yield { kind: 'finish', object, usage, finishReason, ...(providerItems ? { providerItems } : {}) };
 }
 function extractResponsesText(response) {
     if (typeof response.output_text === 'string')
@@ -569,8 +603,11 @@ function accumulateResponsesToolCallDelta(state, event) {
 function accumulateResponsesToolCallDone(state, event) {
     const index = typeof event.output_index === 'number' ? event.output_index : 0;
     const existing = state.get(index) ?? { args: '' };
-    existing.id ??= String(event.item_id);
-    existing.name = String(event.name);
+    // `event.item_id` is the `fc_…` item id, not the `call_…` id required for
+    // `function_call_output`, so the call id only ever comes from the
+    // `response.output_item.added`/`done` events.
+    if (event.name)
+        existing.name = String(event.name);
     if (typeof event.arguments === 'string')
         existing.args = event.arguments;
     state.set(index, existing);
@@ -578,12 +615,17 @@ function accumulateResponsesToolCallDone(state, event) {
 function finalizeResponsesStreamToolCalls(state, req, method) {
     return [...state.entries()]
         .sort((a, b) => a[0] - b[0])
-        .filter(([, call]) => call.id && call.name)
-        .map(([, call]) => ({
-        id: call.id,
-        name: call.name,
-        arguments: parseToolArgs(call.args || undefined, req, method)
-    }));
+        .filter(([, call]) => call.name)
+        .map(([, call]) => {
+        if (!call.id) {
+            throw malformedResponseError(req, method, 'OpenAI streamed a function call without a call_id.', call, undefined);
+        }
+        return {
+            id: call.id,
+            name: call.name,
+            arguments: parseToolArgs(call.args || undefined, req, method)
+        };
+    });
 }
 function accumulateToolCallDeltas(state, deltas) {
     for (const delta of deltas) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purista/harness-openai",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "OpenAI model provider adapter for @purista/harness.",
   "type": "module",
   "main": "./dist/index.js",