@omnicross/core 0.1.5 → 0.1.6

package/dist/{chunk-3Q6Z6JTO.cjs → chunk-6VUQPOV3.cjs}

@@ -104,24 +104,37 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
   async transformRequestOut(request, _context) {
     const req = request;
     const messages = [];
+    let codexTools = null;
+    const instructions = typeof req.instructions === "string" ? req.instructions.trim() : "";
+    if (instructions) {
+      messages.push({ role: "system", content: instructions });
+    }
     if (req.input) {
       for (const item of req.input) {
         const entry = item;
-        if (entry.type === "function_call_output") {
+        const itemType = typeof entry.type === "string" ? entry.type : void 0;
+        if (itemType && SKIPPED_INPUT_ITEM_TYPES.has(itemType)) continue;
+        if (itemType === "additional_tools") {
+          codexTools = collectCodexTools(entry);
+          continue;
+        }
+        if (itemType === "custom_tool_call_output") {
           messages.push({
             role: "tool",
-            content: entry.output || "",
+            content: flattenContent(entry.output),
             tool_call_id: entry.call_id || void 0
           });
           continue;
         }
-        if (entry.type === "function_call") {
+        if (itemType === "custom_tool_call") {
           const toolCall = {
             id: (_nullishCoalesce(entry.call_id, () => ( entry.id))) || "",
             type: "function",
             function: {
               name: entry.name || "",
-              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
+              arguments: JSON.stringify({
+                input: typeof entry.input === "string" ? entry.input : ""
+              })
             }
           };
           const last = messages[messages.length - 1];
@@ -132,17 +145,38 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
           }
           continue;
         }
-        const role = entry.role;
-        if (role === "developer") {
+        if (itemType === "function_call_output") {
           messages.push({
-            role: "system",
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
+            role: "tool",
+            content: flattenContent(entry.output),
+            tool_call_id: entry.call_id || void 0
           });
+          continue;
+        }
+        if (itemType === "function_call") {
+          const toolCall = {
+            id: (_nullishCoalesce(entry.call_id, () => ( entry.id))) || "",
+            type: "function",
+            function: {
+              name: entry.name || "",
+              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
+            }
+          };
+          const last = messages[messages.length - 1];
+          if (last && last.role === "assistant") {
+            (last.tool_calls ??= []).push(toolCall);
+          } else {
+            messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
+          }
+          continue;
+        }
+        const role = entry.role;
+        const text = flattenContent(entry.content);
+        if (!text) continue;
+        if (role === "developer" || role === "system") {
+          messages.push({ role: "system", content: text });
         } else if (role === "user" || role === "assistant") {
-          messages.push({
-            role,
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
+          messages.push({ role, content: text });
         }
       }
     }
@@ -159,15 +193,32 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
         enabled: true
       };
     }
+    const tools = [];
     if (_optionalChain([req, 'access', _9 => _9.tools, 'optionalAccess', _10 => _10.length])) {
-      result.tools = req.tools.filter((t) => t.type === "function").map((t) => ({
-        type: "function",
-        function: {
-          name: t.name || "",
-          description: t.description || "",
-          parameters: t.parameters || {}
+      tools.push(
+        ...req.tools.filter((t) => t.type === "function").map((t) => ({
+          type: "function",
+          function: {
+            name: t.name || "",
+            description: t.description || "",
+            parameters: t.parameters || {}
+          }
+        }))
+      );
+    }
+    if (_optionalChain([codexTools, 'optionalAccess', _11 => _11.tools, 'access', _12 => _12.length])) {
+      const declared = new Set(tools.map((t) => t.function.name));
+      tools.push(...codexTools.tools.filter((t) => !declared.has(t.function.name)));
+    }
+    if (tools.length) result.tools = tools;
+    if (_optionalChain([codexTools, 'optionalAccess', _13 => _13.customToolNames, 'access', _14 => _14.length]) || Object.keys(_nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _15 => _15.toolNamespaces]), () => ( {}))).length) {
+      result.meta = {
+        ...result.meta,
+        codexTools: {
+          ...codexTools.customToolNames.length ? { customToolNames: codexTools.customToolNames } : {},
+          ...Object.keys(codexTools.toolNamespaces).length ? { toolNamespaces: codexTools.toolNamespaces } : {}
         }
-      }));
+      };
     }
     return result;
   }
@@ -208,13 +259,14 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
   /**
    * Transform OpenAI CC response → Response API format
    */
-  async transformResponseIn(response, _context) {
+  async transformResponseIn(response, context) {
     const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+    const codexTools = _optionalChain([context, 'optionalAccess', _16 => _16.req, 'optionalAccess', _17 => _17.meta, 'optionalAccess', _18 => _18.codexTools]);
     if (contentType.includes("text/event-stream")) {
       if (!response.body) {
         throw new Error("Stream response body is null");
       }
-      return new Response(convertOpenAIStreamToResponseApi(response.body), {
+      return new Response(convertOpenAIStreamToResponseApi(response.body, codexTools), {
         headers: {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache",
@@ -223,16 +275,114 @@ var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototyp
       });
     }
     const data = await response.json();
-    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data)), {
+    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data, codexTools)), {
       headers: { "Content-Type": "application/json" }
     });
   }
 }, _class.__initStatic(), _class);
+var TEXT_PART_TYPES = /* @__PURE__ */ new Set(["text", "input_text", "output_text", "summary_text"]);
+var SKIPPED_INPUT_ITEM_TYPES = /* @__PURE__ */ new Set(["reasoning", "agent_message"]);
+var CUSTOM_TOOL_PARAMETERS = {
+  type: "object",
+  properties: {
+    input: {
+      type: "string",
+      description: "The complete free-form input for this tool, passed through verbatim."
+    }
+  },
+  required: ["input"]
+};
+function unwrapCustomToolInput(argumentsJson) {
+  try {
+    const parsed = JSON.parse(argumentsJson);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") {
+      return parsed.input;
+    }
+  } catch (e3) {
+  }
+  return argumentsJson;
+}
+function encodeToolCallItem(callId, name, argumentsJson, status, codexTools) {
+  const bareId = callId.replace(/^(call_|fc_|ctc_)/, "");
+  if (_optionalChain([codexTools, 'optionalAccess', _19 => _19.customToolNames, 'optionalAccess', _20 => _20.includes, 'call', _21 => _21(name)])) {
+    return {
+      id: `ctc_${bareId}`,
+      type: "custom_tool_call",
+      status,
+      call_id: callId,
+      name,
+      input: unwrapCustomToolInput(argumentsJson)
+    };
+  }
+  const namespace = _optionalChain([codexTools, 'optionalAccess', _22 => _22.toolNamespaces, 'optionalAccess', _23 => _23[name]]);
+  return {
+    id: callId.startsWith("fc_") ? callId : `fc_${bareId}`,
+    type: "function_call",
+    status,
+    call_id: callId,
+    name,
+    ...namespace ? { namespace } : {},
+    arguments: argumentsJson
+  };
+}
+function collectCodexTools(entry) {
+  const result = { tools: [], customToolNames: [], toolNamespaces: {} };
+  const visit = (declarations, namespace) => {
+    if (!Array.isArray(declarations)) return;
+    for (const raw of declarations) {
+      if (!raw || typeof raw !== "object") continue;
+      const tool = raw;
+      const name = typeof tool.name === "string" ? tool.name : "";
+      if (!name) continue;
+      const description = typeof tool.description === "string" ? tool.description : "";
+      if (tool.type === "namespace") {
+        visit(tool.tools, name);
+        continue;
+      }
+      if (tool.type === "custom") {
+        result.customToolNames.push(name);
+        result.tools.push({
+          type: "function",
+          function: {
+            name,
+            description,
+            parameters: CUSTOM_TOOL_PARAMETERS
+          }
+        });
+      } else if (tool.type === "function") {
+        result.tools.push({
+          type: "function",
+          function: {
+            name,
+            description,
+            parameters: tool.parameters || {}
+          }
+        });
+      } else {
+        continue;
+      }
+      if (namespace) result.toolNamespaces[name] = namespace;
+    }
+  };
+  visit(entry.tools);
+  return result;
+}
 function flattenContent(content) {
   if (typeof content === "string") return content;
   if (!content) return "";
   if (Array.isArray(content)) {
-    return content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (!part || typeof part !== "object") return "";
+      const c = part;
+      if (typeof c.type === "string" && !TEXT_PART_TYPES.has(c.type)) return "";
+      return typeof c.text === "string" ? c.text : "";
+    }).filter((text) => text !== "").join("\n");
+  }
+  if (typeof content === "object") {
+    const obj = content;
+    if (typeof obj.text === "string") return obj.text;
+    if (Array.isArray(obj.content)) return flattenContent(obj.content);
   }
   return "";
 }
@@ -290,9 +440,9 @@ function convertResponseApiJsonToOpenAI(data) {
     } : void 0
   };
 }
-function convertOpenAIJsonToResponseApi(data) {
+function convertOpenAIJsonToResponseApi(data, codexTools) {
   const choices = data.choices;
-  const message = _optionalChain([choices, 'optionalAccess', _11 => _11[0], 'optionalAccess', _12 => _12.message]);
+  const message = _optionalChain([choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.message]);
   const output = [];
   if (message) {
     const contentParts = [];
@@ -303,16 +453,18 @@ function convertOpenAIJsonToResponseApi(data) {
       output.push({ type: "message", role: "assistant", content: contentParts });
     }
     const toolCalls = message.tool_calls;
-    if (_optionalChain([toolCalls, 'optionalAccess', _13 => _13.length])) {
+    if (_optionalChain([toolCalls, 'optionalAccess', _26 => _26.length])) {
       for (const tc of toolCalls) {
         const func = tc.function;
-        output.push({
-          type: "function_call",
-          id: tc.id,
-          call_id: tc.id,
-          name: _optionalChain([func, 'optionalAccess', _14 => _14.name]),
-          arguments: _optionalChain([func, 'optionalAccess', _15 => _15.arguments])
-        });
+        output.push(
+          encodeToolCallItem(
+            tc.id || "",
+            _optionalChain([func, 'optionalAccess', _27 => _27.name]) || "",
+            typeof _optionalChain([func, 'optionalAccess', _28 => _28.arguments]) === "string" ? func.arguments : "",
+            "completed",
+            codexTools
+          )
+        );
       }
     }
   }
@@ -346,7 +498,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
         if (!isClosed) {
           try {
             controller.enqueue(encoder.encode(str));
-          } catch (e3) {
+          } catch (e4) {
             isClosed = true;
           }
         }
@@ -378,7 +530,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
             if (data === "[DONE]") continue;
             try {
               const event = JSON.parse(data);
-              model = event.model || _optionalChain([event, 'access', _16 => _16.response, 'optionalAccess', _17 => _17.model]) || model;
+              model = event.model || _optionalChain([event, 'access', _29 => _29.response, 'optionalAccess', _30 => _30.model]) || model;
               switch (event.type) {
                 case "response.output_text.delta":
                   if (event.delta) {
@@ -400,7 +552,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                   break;
                 case "response.output_item.added": {
                   const item = event.item;
-                  if (_optionalChain([item, 'optionalAccess', _18 => _18.type]) !== "function_call") break;
+                  if (_optionalChain([item, 'optionalAccess', _31 => _31.type]) !== "function_call") break;
                   if (!hasEmittedRole) {
                     emitChunk([{ index: 0, delta: { role: "assistant", content: null }, finish_reason: null }]);
                     hasEmittedRole = true;
@@ -436,7 +588,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 }
                 case "response.completed": {
                   const resp = event.response;
-                  const respUsage = _optionalChain([resp, 'optionalAccess', _19 => _19.usage]);
+                  const respUsage = _optionalChain([resp, 'optionalAccess', _32 => _32.usage]);
                   const usage = respUsage ? {
                     prompt_tokens: respUsage.input_tokens || 0,
                     completion_tokens: respUsage.output_tokens || 0,
@@ -449,14 +601,14 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
                 case "error":
                   emitChunk([{
                     index: 0,
-                    delta: { content: `[Error: ${_optionalChain([event, 'access', _20 => _20.error, 'optionalAccess', _21 => _21.message]) || "Unknown error"}]` },
+                    delta: { content: `[Error: ${_optionalChain([event, 'access', _33 => _33.error, 'optionalAccess', _34 => _34.message]) || "Unknown error"}]` },
                     finish_reason: "stop"
                   }]);
                   break;
                 default:
                   break;
               }
-            } catch (e4) {
+            } catch (e5) {
             }
           }
         }
@@ -466,7 +618,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
         if (!isClosed) {
           try {
             controller.close();
-          } catch (e5) {
+          } catch (e6) {
           }
         }
         reader.releaseLock();
@@ -474,7 +626,7 @@ function convertResponseApiStreamToOpenAI(responseApiStream) {
     }
   });
 }
-function convertOpenAIStreamToResponseApi(openaiStream) {
+function convertOpenAIStreamToResponseApi(openaiStream, codexTools) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   return new ReadableStream({
@@ -485,6 +637,8 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
       let accumulatedContent = "";
       let model = "unknown";
       const responseId = `resp_${Date.now()}`;
+      const messageId = `msg_${Date.now()}`;
+      let messageItemAdded = false;
       const toolCalls = /* @__PURE__ */ new Map();
       const toolOutputIndex = /* @__PURE__ */ new Map();
       let nextOutputIndex = 1;
@@ -492,7 +646,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
         if (!isClosed) {
           try {
             controller.enqueue(encoder.encode(str));
-          } catch (e6) {
+          } catch (e7) {
             isClosed = true;
           }
         }
@@ -520,20 +674,40 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
             if (data === "[DONE]") continue;
             try {
               const chunk = JSON.parse(data);
-              const choice = _optionalChain([chunk, 'access', _22 => _22.choices, 'optionalAccess', _23 => _23[0]]);
+              const choice = _optionalChain([chunk, 'access', _35 => _35.choices, 'optionalAccess', _36 => _36[0]]);
               model = chunk.model || model;
               if (!choice) continue;
-              if (_optionalChain([choice, 'access', _24 => _24.delta, 'optionalAccess', _25 => _25.content])) {
+              if (_optionalChain([choice, 'access', _37 => _37.delta, 'optionalAccess', _38 => _38.content])) {
+                if (!messageItemAdded) {
+                  messageItemAdded = true;
+                  emitEvent({
+                    type: "response.output_item.added",
+                    output_index: 0,
+                    item: {
+                      id: messageId,
+                      type: "message",
+                      role: "assistant",
+                      status: "in_progress",
+                      content: []
+                    }
+                  });
+                }
                 accumulatedContent += choice.delta.content;
-                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
+                emitEvent({
+                  type: "response.output_text.delta",
+                  output_index: 0,
+                  content_index: 0,
+                  delta: choice.delta.content
+                });
               }
-              if (_optionalChain([choice, 'access', _26 => _26.delta, 'optionalAccess', _27 => _27.thinking, 'optionalAccess', _28 => _28.content])) {
+              const reasoningDelta = _nullishCoalesce(_optionalChain([choice, 'access', _39 => _39.delta, 'optionalAccess', _40 => _40.thinking, 'optionalAccess', _41 => _41.content]), () => ( _optionalChain([choice, 'access', _42 => _42.delta, 'optionalAccess', _43 => _43.reasoning_content])));
+              if (reasoningDelta) {
                 emitEvent({
                   type: "response.reasoning_summary_text.delta",
-                  delta: choice.delta.thinking.content
+                  delta: reasoningDelta
                 });
               }
-              if (_optionalChain([choice, 'access', _29 => _29.delta, 'optionalAccess', _30 => _30.tool_calls])) {
+              if (_optionalChain([choice, 'access', _44 => _44.delta, 'optionalAccess', _45 => _45.tool_calls])) {
                 for (const tc of choice.delta.tool_calls) {
                   const tcIndex = typeof tc["index"] === "number" ? tc["index"] : 0;
                   const func = _nullishCoalesce(tc["function"], () => ( {}));
@@ -541,66 +715,83 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
                   if (!entry) {
                     const callId = typeof tc["id"] === "string" ? tc["id"] : `call_${Date.now()}_${tcIndex}`;
                     const name = typeof func["name"] === "string" ? func["name"] : "";
-                    entry = { callId, name, arguments: "" };
+                    entry = {
+                      callId,
+                      name,
+                      arguments: "",
+                      isCustom: _nullishCoalesce(_optionalChain([codexTools, 'optionalAccess', _46 => _46.customToolNames, 'optionalAccess', _47 => _47.includes, 'call', _48 => _48(name)]), () => ( false))
+                    };
                     toolCalls.set(tcIndex, entry);
                     const outIdx = nextOutputIndex++;
                     toolOutputIndex.set(tcIndex, outIdx);
-                    const itemId = callId.startsWith("fc_") ? callId : `fc_${callId.replace(/^(call_|fc_)/, "")}`;
                     emitEvent({
                       type: "response.output_item.added",
                       output_index: outIdx,
-                      item: {
-                        id: itemId,
-                        type: "function_call",
-                        status: "in_progress",
-                        call_id: callId,
-                        name,
-                        arguments: ""
-                      }
+                      item: encodeToolCallItem(callId, name, "", "in_progress", codexTools)
                     });
                   }
                   const argsFragment = typeof func["arguments"] === "string" ? func["arguments"] : "";
                   if (argsFragment) {
                     entry.arguments += argsFragment;
-                    emitEvent({
-                      type: "response.function_call_arguments.delta",
-                      output_index: toolOutputIndex.get(tcIndex),
-                      delta: argsFragment
-                    });
+                    if (!entry.isCustom) {
+                      emitEvent({
+                        type: "response.function_call_arguments.delta",
+                        output_index: toolOutputIndex.get(tcIndex),
+                        delta: argsFragment
+                      });
+                    }
                   }
                 }
               }
               if (choice.finish_reason) {
-                emitEvent({ type: "response.output_text.done", text: accumulatedContent });
                 const output = [];
-                if (accumulatedContent) {
-                  output.push({
+                if (messageItemAdded) {
+                  emitEvent({
+                    type: "response.output_text.done",
+                    output_index: 0,
+                    content_index: 0,
+                    text: accumulatedContent
+                  });
+                  const messageItem = {
+                    id: messageId,
                     type: "message",
                     role: "assistant",
+                    status: "completed",
                     content: [{ type: "output_text", text: accumulatedContent }]
+                  };
+                  emitEvent({
+                    type: "response.output_item.done",
+                    output_index: 0,
+                    item: messageItem
                   });
+                  output.push(messageItem);
                 }
                 for (const [tcIndex, entry] of toolCalls) {
-                  const itemId = entry.callId.startsWith("fc_") ? entry.callId : `fc_${entry.callId.replace(/^(call_|fc_)/, "")}`;
-                  output.push({
-                    id: itemId,
-                    type: "function_call",
-                    status: "completed",
-                    call_id: entry.callId,
-                    name: entry.name,
-                    arguments: entry.arguments
-                  });
+                  const outIdx = toolOutputIndex.get(tcIndex);
+                  const item = encodeToolCallItem(
+                    entry.callId,
+                    entry.name,
+                    entry.arguments,
+                    "completed",
+                    codexTools
+                  );
+                  if (entry.isCustom) {
+                    emitEvent({
+                      type: "response.custom_tool_call_input.delta",
+                      output_index: outIdx,
+                      delta: item.input
+                    });
+                    emitEvent({
+                      type: "response.custom_tool_call_input.done",
+                      output_index: outIdx,
+                      input: item.input
+                    });
+                  }
+                  output.push(item);
                   emitEvent({
                     type: "response.output_item.done",
-                    output_index: toolOutputIndex.get(tcIndex),
-                    item: {
-                      id: itemId,
-                      type: "function_call",
-                      status: "completed",
-                      call_id: entry.callId,
-                      name: entry.name,
-                      arguments: entry.arguments
-                    }
+                    output_index: outIdx,
+                    item
                   });
                 }
                 emitEvent({
@@ -618,7 +809,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
                   }
                 });
               }
-            } catch (e7) {
+            } catch (e8) {
             }
           }
         }
@@ -628,7 +819,7 @@ function convertOpenAIStreamToResponseApi(openaiStream) {
         if (!isClosed) {
           try {
             controller.close();
-          } catch (e8) {
+          } catch (e9) {
           }
         }
         reader.releaseLock();

package/dist/chunk-7AK7B36B.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkV4TXMEJScjs = require('./chunk-V4TXMEJS.cjs');
+
+
+var _chunk6VUQPOV3cjs = require('./chunk-6VUQPOV3.cjs');
+
+
+var _chunkOF3BECU2cjs = require('./chunk-OF3BECU2.cjs');
+
+
+var _chunk4VLRHHFEcjs = require('./chunk-4VLRHHFE.cjs');
+
+
+var _chunkOKMJLEXXcjs = require('./chunk-OKMJLEXX.cjs');
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  OpenAITransformer: _chunkOF3BECU2cjs.OpenAITransformer,
+  GeminiTransformer: _chunkV4TXMEJScjs.GeminiTransformer,
+  GeminiCodeAssistTransformer: _chunkOKMJLEXXcjs.GeminiCodeAssistTransformer,
+  AnthropicTransformer: _chunk4VLRHHFEcjs.AnthropicTransformer,
+  OpenAIResponseTransformer: _chunk6VUQPOV3cjs.OpenAIResponseTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "openai",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+
+
+
+
+
+exports.BuiltinTransformers = BuiltinTransformers; exports.getBuiltinTransformers = getBuiltinTransformers; exports.BUILTIN_TRANSFORMER_NAMES = BUILTIN_TRANSFORMER_NAMES; exports.registerBuiltinTransformers = registerBuiltinTransformers;

package/dist/{chunk-5ZQBEOMD.js → chunk-AT7B7SOZ.js}

@@ -59,6 +59,26 @@ function hasThinkingEnabled(request) {
   }
   return false;
 }
+function flattenToolResultContent(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  if (!Array.isArray(content)) return JSON.stringify(content);
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (!block || typeof block !== "object") continue;
+    const typed = block;
+    if (typed.type === "image" || typed.type === "image_url") {
+      parts.push("[image omitted]");
+    } else if (typeof typed.text === "string") {
+      parts.push(typed.text);
+    }
+  }
+  return parts.filter((text) => text !== "").join("\n");
+}
 
 // src/api-converter/anthropic-to-openai.ts
 function convertAnthropicToOpenAI(response) {
@@ -158,7 +178,7 @@ function convertAnthropicRequestToOpenAI(request) {
           });
         } else if (part.type === "tool_result") {
           toolResultId = part.tool_use_id;
-          toolResultContent = typeof part.content === "string" ? part.content : JSON.stringify(part.content);
+          toolResultContent = flattenToolResultContent(part.content);
         }
       }
       if (toolResultId && toolResultContent !== void 0) {
@@ -368,7 +388,10 @@ function convertOpenAIToAnthropic(request, config) {
       const toolResult = {
         type: "tool_result",
         tool_use_id: msg.tool_call_id,
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        // An OpenAI tool message is normally a plain string, but a parts array
+        // must be flattened to text rather than stringified into a literal
+        // `[{"type":"text",…}]` envelope the model then has to read.
+        content: flattenToolResultContent(msg.content)
       };
       const lastMsg = messages[messages.length - 1];
       if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {

package/dist/{chunk-IK3KE3AU.js → chunk-DE2SRBFZ.js}

@@ -28,7 +28,7 @@ async function executeProviderCall(ctx) {
   }
   const fetched = await fetchFn(url, headers, finalBody);
   let response = fetched;
-  if (runResponseChain) {
+  if (runResponseChain && fetched.ok) {
     response = await executor.executeResponseChain(
       // Preserve the EXACT first arg each site passed: proxy → requestBody,
       // unified ingresses → their pre-transform request. The caller supplies