@toren-run/providers 0.1.2 → 0.1.4

package/dist/openai.d.ts

@@ -2,6 +2,10 @@ import type OpenAI from "openai";
 import type { ModelProvider, ModelRequest, ModelResponse } from "@toren-run/core";
 export declare function toOpenAIParams(req: ModelRequest): OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
 export declare function fromOpenAIResponse(completion: OpenAI.Chat.Completions.ChatCompletion): ModelResponse;
+/** Real reasoning effort ("low"/"medium"/"high") needs /v1/responses; "none" or absent works on chat/completions. */
+export declare function usesResponsesApi(req: Pick<ModelRequest, "reasoningEffort">): boolean;
+export declare function toResponsesParams(req: ModelRequest): OpenAI.Responses.ResponseCreateParamsNonStreaming;
+export declare function fromResponsesResponse(res: OpenAI.Responses.Response): ModelResponse;
 /**
  * OpenAI adapter over toren's normalized model interface.
  * Credentials resolve from the environment (OPENAI_API_KEY);

package/dist/openai.js

@@ -64,6 +64,8 @@ export function toOpenAIParams(req) {
     return {
         model: req.model.replace(/^openai\//, ""),
         max_completion_tokens: req.maxTokens,
+        // gpt-5.6+ reject tools via chat/completions unless reasoning_effort is set.
+        ...(req.reasoningEffort ? { reasoning_effort: req.reasoningEffort } : {}),
         messages: [
             ...(req.system ? [{ role: "system", content: req.system }] : []),
             ...toSdkMessages(req.messages),
@@ -113,6 +115,82 @@ export function fromOpenAIResponse(completion) {
         },
     };
 }
+// ---- /v1/responses: the API that allows reasoning AND tools together.
+// gpt-5.6+ reject function tools on chat/completions unless reasoning is off,
+// so a request with real reasoning effort routes here; everything else stays
+// on the battle-tested chat/completions path. The digest covers toren's
+// normalized request, not the wire shape, so routing changes nothing in-flight.
+/** Real reasoning effort ("low"/"medium"/"high") needs /v1/responses; "none" or absent works on chat/completions. */
+export function usesResponsesApi(req) {
+    return Boolean(req.reasoningEffort && req.reasoningEffort !== "none");
+}
+export function toResponsesParams(req) {
+    const input = [];
+    for (const m of req.messages) {
+        if (m.role === "assistant") {
+            const text = m.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+            if (text)
+                input.push({ role: "assistant", content: [{ type: "output_text", text, annotations: [] }] });
+            for (const b of m.content) {
+                if (b.type === "toolUse")
+                    input.push({ type: "function_call", call_id: b.id, name: b.name, arguments: JSON.stringify(b.input ?? {}) });
+            }
+            continue;
+        }
+        let text = "";
+        for (const b of m.content) {
+            if (b.type === "toolResult")
+                input.push({ type: "function_call_output", call_id: b.toolUseId, output: b.isError ? `ERROR: ${b.content}` : b.content });
+            else if (b.type === "text")
+                text += b.text;
+        }
+        if (text)
+            input.push({ role: "user", content: [{ type: "input_text", text }] });
+    }
+    return {
+        model: req.model.replace(/^openai\//, ""),
+        ...(req.system ? { instructions: req.system } : {}),
+        max_output_tokens: req.maxTokens,
+        reasoning: { effort: req.reasoningEffort },
+        input,
+        ...(req.tools.length
+            ? { tools: req.tools.map((t) => ({ type: "function", name: t.name, description: t.description, parameters: t.inputSchema, strict: false })) }
+            : {}),
+    };
+}
+export function fromResponsesResponse(res) {
+    const content = [];
+    for (const item of res.output ?? []) {
+        if (item.type === "message") {
+            const text = item.content.filter((c) => c.type === "output_text").map((c) => c.text).join("");
+            if (text)
+                content.push({ type: "text", text });
+        }
+        else if (item.type === "function_call") {
+            let input = {};
+            try {
+                input = JSON.parse(item.arguments || "{}");
+            }
+            catch {
+                input = { _raw: item.arguments };
+            }
+            content.push({ type: "toolUse", id: item.call_id, name: item.name, input });
+        }
+        // reasoning items are the model's private scratchpad: not transcript content.
+    }
+    const stopReason = content.some((b) => b.type === "toolUse")
+        ? "toolUse"
+        : res.status === "incomplete" && res.incomplete_details?.reason === "max_output_tokens"
+            ? "maxTokens"
+            : res.status === "incomplete" && res.incomplete_details?.reason === "content_filter"
+                ? "refusal"
+                : "endTurn";
+    return {
+        content,
+        stopReason,
+        usage: { inputTokens: res.usage?.input_tokens ?? 0, outputTokens: res.usage?.output_tokens ?? 0 },
+    };
+}
 /**
  * OpenAI adapter over toren's normalized model interface.
  * Credentials resolve from the environment (OPENAI_API_KEY);
@@ -124,6 +202,9 @@ export class OpenAIProvider {
         this.client = client ?? new (loadSdk())();
     }
     async complete(req) {
+        if (usesResponsesApi(req)) {
+            return fromResponsesResponse(await this.client.responses.create(toResponsesParams(req)));
+        }
         const response = await this.client.chat.completions.create(toOpenAIParams(req));
         return fromOpenAIResponse(response);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toren-run/providers",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "exports": {
     ".": {
@@ -11,7 +11,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.110.0",
     "openai": "^4.68.0",
-    "@toren-run/core": "^0.1.2"
+    "@toren-run/core": "^0.1.4"
   },
   "description": "Model provider adapters for Toren (Anthropic, OpenAI) — each SDK loads lazily on first use.",
   "license": "Apache-2.0",