@jeffusion/bungee-core 6.10.0 → 6.11.0

package/dist/plugins/llm-protocol-adapter/index.js

@@ -3763,8 +3763,9 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
     if (typeof rawContent === "string")
       return rawContent;
     const parts = list(rawContent, "message content");
-    for (const [index, rawPart] of parts.entries())
-      atParam(path ? `${path}[${index}]` : messageParam, () => {
+    for (const [index, rawPart] of parts.entries()) {
+      const partPath = `${path}[${index}]`;
+      atParam(partPath, () => {
         const part = record(rawPart, "content part");
         if (part.type === "input_text" || part.type === "output_text" || part.type === "text")
           string(part.text, "content text");
@@ -3772,17 +3773,21 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
           string(part.refusal, "refusal");
           if (capabilities.preserveRefusalContent && protocol !== "chat_completions")
             fail("unsupported_content", "Target protocol cannot preserve refusal history authority");
-        } else if (part.type === "input_image" && (role === "user" || role === "tool" && options.toolOutputImages)) {
+        } else if (part.type === "input_image" && (role === "user" || role === "tool")) {
           if (protocol !== "chat_completions")
             fail("unsupported_content", "Anthropic image conversion requires provider-specific URL/data support");
+          for (const key of Object.keys(part))
+            if (!["type", "image_url", "detail"].includes(key))
+              fail("unsupported_content", "Unsupported image field", `${partPath}.${key}`);
           string(part.image_url, "image_url", true);
-          if (part.detail !== undefined && !["auto", "low", "high"].includes(String(part.detail)))
-            fail("unsupported_content", "Unknown image detail", path ? `${path}[${index}].detail` : undefined);
+          if (part.detail !== undefined && (typeof part.detail !== "string" || !["auto", "low", "high"].includes(part.detail)))
+            fail("unsupported_content", "Unknown image detail", `${partPath}.detail`);
         } else
           fail("unsupported_content", "Unsupported message content type");
         if (part.annotations !== undefined && list(part.annotations, "annotations").length)
           fail("unsupported_content", "Output annotations cannot be represented in input history");
       });
+    }
     const normalized = contentNormalizer.normalizeResponsesMessageContent(parts.map((raw) => {
       const part = raw;
       return part.type === "refusal" ? { type: "output_text", text: part.refusal } : part;
@@ -3796,11 +3801,23 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
     }
     return normalized;
   };
+  const appendAssistantContent = (previous, next) => {
+    if (previous == null)
+      return next;
+    if (next == null)
+      return previous;
+    if (typeof previous === "string" && typeof next === "string")
+      return previous + next;
+    const parts = (value) => typeof value === "string" ? [{ type: "text", text: value }] : Array.isArray(value) ? value : [value];
+    return [...parts(previous), ...parts(next)];
+  };
   const chat = [];
   const messageParams = new WeakMap;
   let messageParam = "instructions";
   const callIds = new Set;
+  const callToolNames = new Map;
   const answered = new Set;
+  const projectedToolImages = [];
   let pendingReasoning = "";
   const addMessage = (message) => {
     if (chat.length >= budget.maxItems)
@@ -3808,12 +3825,21 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
     chat.push(message);
     messageParams.set(message, messageParam);
   };
+  const flushToolImages = (force = false) => {
+    if (!force && [...callIds].some((id) => !answered.has(id)))
+      return;
+    for (const { callId, name, images } of projectedToolImages)
+      addMessage({ role: "user", content: [{ type: "text", text: `Images returned by tool ${JSON.stringify(name)} (call ${JSON.stringify(callId)}):` }, ...images] });
+    projectedToolImages.length = 0;
+  };
   if (body.instructions !== undefined)
     addMessage({ role: "system", content: string(body.instructions, "instructions") });
   for (const [inputIndex, rawItem] of input.entries())
     atParam(`input[${inputIndex}]`, () => {
       messageParam = `input[${inputIndex}]`;
       const item = record(rawItem, "input item");
+      if (item.type !== "function_call_output" && item.type !== "custom_tool_call_output")
+        flushToolImages();
       if (item.type === "additional_tools")
         return;
       if (item.type === "agent_message") {
@@ -3862,11 +3888,12 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
         bounded(args, budget.maxArgumentBytes, "arguments");
         argumentObject(args);
         const call = { id, type: "function", function: { name: resolve(item, custom), arguments: args } };
+        callToolNames.set(id, String(item.name));
         const previous = chat.at(-1);
         if (previous?.role === "assistant" && !options.preserveContentOrder) {
           previous.tool_calls = [...previous.tool_calls ?? [], call];
           if (pendingReasoning)
-            previous.reasoning_content = pendingReasoning;
+            previous.reasoning_content = previous.reasoning_content === undefined ? pendingReasoning : `${previous.reasoning_content}${pendingReasoning}`;
         } else
           addMessage({ role: "assistant", content: null, tool_calls: [call], ...pendingReasoning ? { reasoning_content: pendingReasoning } : {} });
         pendingReasoning = "";
@@ -3877,7 +3904,21 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
         if (!callIds.has(id) || answered.has(id))
           fail("invalid_tool_history", "Unmatched or duplicate tool result");
         answered.add(id);
-        const output = typeof item.output === "string" ? item.output : normalizeContent(item.output, "tool", `${messageParam}.output`);
+        if (Array.isArray(item.output) && item.output.length > budget.maxItems && item.output.some((part) => part && typeof part === "object" && part.type === "input_image"))
+          fail("resource_limit", "Too many tool output content parts", `${messageParam}.output`);
+        let output = typeof item.output === "string" ? item.output : normalizeContent(item.output, "tool", `${messageParam}.output`);
+        if (protocol === "chat_completions" && !options.toolOutputImages && Array.isArray(output)) {
+          const images = output.filter((part) => part.type === "image_url");
+          if (images.length) {
+            output.forEach((part, index) => {
+              if (part.type === "image_url")
+                diagnostics.push({ param: `${messageParam}.output[${index}]`, action: "mapped", reason: "chat_tool_image_projected_to_user_message" });
+            });
+            const text = output.filter((part) => part.type !== "image_url");
+            projectedToolImages.push({ callId: id, name: callToolNames.get(id) ?? id, images });
+            output = text.length ? text : "Tool output contained only images; see the following images.";
+          }
+        }
         addMessage({ role: "tool", tool_call_id: id, content: output, ...item.is_error === true ? { is_error: true } : {} });
         return;
       }
@@ -3886,7 +3927,7 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
       const role = string(item.role, "message role", true);
       if (!["user", "assistant", "system", "developer"].includes(role))
         fail("unsupported_content", "Unknown message role");
-      const message = { role, content: normalizeContent(item.content, role) };
+      const message = { role, content: normalizeContent(item.content, role, `${messageParam}.content`) };
       if (options.preserveContentOrder && item.id !== undefined)
         message.id = string(item.id, "item.id", true);
       if (pendingReasoning) {
@@ -3895,10 +3936,20 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
         message.reasoning_content = pendingReasoning;
         pendingReasoning = "";
       }
+      if (protocol === "chat_completions" && !options.preserveContentOrder && role === "assistant") {
+        const previous = chat.at(-1);
+        if (previous?.role === "assistant") {
+          previous.content = appendAssistantContent(previous.content, message.content);
+          if (message.reasoning_content !== undefined)
+            previous.reasoning_content = previous.reasoning_content === undefined ? message.reasoning_content : `${previous.reasoning_content}${message.reasoning_content}`;
+          return;
+        }
+      }
       addMessage(message);
     });
   if (pendingReasoning)
     fail("unsupported_reasoning", "Orphan reasoning history cannot be represented");
+  flushToolImages(true);
   const result = { model, messages: chat };
   const omittedAllTools = !tools.length && diagnostics.some((item) => item.reason === "optional_hosted_web_search_unavailable");
   for (const key of ["stream", "temperature", "top_p", "parallel_tool_calls", "metadata"])
@@ -5403,14 +5454,21 @@ function validateProviderResponse(raw, protocol) {
     fields2(b, ["id", "object", "created", "model", "choices", "usage", "system_fingerprint", "service_tier"], "", "unsupported_response");
     for (const rawChoice of list(b.choices, "choices")) {
       const c = record(rawChoice, "choice");
-      fields2(c, ["index", "message", "finish_reason", "logprobs"], "choices", "unsupported_response");
+      fields2(c, ["index", "message", "finish_reason", "logprobs", "provider_specific_fields"], "choices", "unsupported_response");
+      if (c.provider_specific_fields !== undefined) {
+        const providerFields = c.provider_specific_fields;
+        if (providerFields === null || typeof providerFields !== "object" || Array.isArray(providerFields) || Object.keys(providerFields).length)
+          fail("unsupported_response", "Only empty provider-specific choice fields are portable", "choices.provider_specific_fields");
+      }
       if (c.logprobs != null)
         fail("unsupported_response", "Log probabilities cannot cross protocols", "choices.logprobs");
       const m = record(c.message, "message");
       fields2(m, ["role", "content", "refusal", "reasoning_content", "reasoning", "tool_calls", "annotations"], "message", "unsupported_content");
-      for (const rawCall of m.tool_calls === undefined ? [] : list(m.tool_calls, "tool_calls")) {
+      for (const [callIndex, rawCall] of (m.tool_calls === undefined ? [] : list(m.tool_calls, "tool_calls")).entries()) {
         const call = record(rawCall, "call");
-        fields2(call, ["id", "type", "function"], "tool_calls", "unsupported_tool");
+        fields2(call, ["id", "type", "function", "index"], "tool_calls", "unsupported_tool");
+        if (call.index !== undefined && integer(call.index, `tool_calls[${callIndex}].index`) !== callIndex)
+          fail("invalid_payload", "Tool call index must match its array position", `tool_calls[${callIndex}].index`);
         fields2(record(call.function, "function"), ["name", "arguments"], "tool_calls.function", "unsupported_tool");
       }
     }
@@ -7512,4 +7570,4 @@ export {
   targetPath
 };
 
-//# debugId=F228E39D1C0449DF64756E2164756E21
+//# debugId=EA74ECD3BF3B21AA64756E2164756E21