@jeffusion/bungee-core 6.8.1 → 6.8.2

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

@@ -3427,14 +3427,20 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
     fail("unsupported_request", "Only one response candidate is supported");
   if (body.truncation !== undefined && body.truncation !== "disabled")
     fail("unsupported_request", "Automatic input truncation cannot be represented");
-  if (body.include !== undefined && list(body.include, "include").some((field) => field !== "reasoning.encrypted_content"))
-    fail("unsupported_request", "Requested extra Responses output fields cannot be represented");
+  const diagnostics = [];
+  if (body.include !== undefined)
+    atParam("include", () => {
+      for (const [index, field] of list(body.include, "include").entries()) {
+        if (field !== "reasoning.encrypted_content" && field !== "output.encrypted_content")
+          fail("unsupported_request", "Requested extra Responses output fields cannot be represented", `include[${index}]`);
+        diagnostics.push({ param: `include[${index}]`, action: "omitted", reason: "target_encrypted_output_unavailable" });
+      }
+    });
   if (body.prompt_cache_key !== undefined)
     string(body.prompt_cache_key, "prompt_cache_key");
   if (body.client_metadata !== undefined)
     record(body.client_metadata, "client_metadata");
   const model = string(body.model, "model", true);
-  const diagnostics = [];
   const input = atParam("input", () => typeof body.input === "string" ? [{ role: "user", content: body.input }] : list(body.input, "input"));
   if (input.length > budget.maxItems)
     fail("resource_limit", "Too many input items", "input");
@@ -3567,29 +3573,30 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
       fail("tool_name_collision", "Historical tool kind conflicts with its current declaration");
     return wire;
   };
-  const normalizeContent = (rawContent, role) => {
+  const normalizeContent = (rawContent, role, path) => {
     if (typeof rawContent === "string")
       return rawContent;
     const parts = list(rawContent, "message content");
-    for (const rawPart of parts) {
-      const part = record(rawPart, "content part");
-      if (part.type === "input_text" || part.type === "output_text" || part.type === "text")
-        string(part.text, "content text");
-      else if (part.type === "refusal" && role === "assistant") {
-        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") {
-        if (protocol !== "chat_completions")
-          fail("unsupported_content", "Anthropic image conversion requires provider-specific URL/data support");
-        string(part.image_url, "image_url", true);
-        if (part.detail !== undefined && !["auto", "low", "high"].includes(String(part.detail)))
-          fail("unsupported_content", "Unknown image 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");
-    }
+    for (const [index, rawPart] of parts.entries())
+      atParam(path ? `${path}[${index}]` : messageParam, () => {
+        const part = record(rawPart, "content part");
+        if (part.type === "input_text" || part.type === "output_text" || part.type === "text")
+          string(part.text, "content text");
+        else if (part.type === "refusal" && role === "assistant") {
+          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)) {
+          if (protocol !== "chat_completions")
+            fail("unsupported_content", "Anthropic image conversion requires provider-specific URL/data support");
+          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);
+        } 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;
@@ -3684,7 +3691,7 @@ 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");
+        const output = typeof item.output === "string" ? item.output : normalizeContent(item.output, "tool", `${messageParam}.output`);
         addMessage({ role: "tool", tool_call_id: id, content: output, ...item.is_error === true ? { is_error: true } : {} });
         return;
       }
@@ -4285,6 +4292,38 @@ function textParts(raw, path, style, role) {
 
 // packages/llms/src/protocol-session/gemini.ts
 var signatureSeparator = "__thought__";
+function geminiInlineImage(image, path, budget) {
+  const param = `${path}.image_url`;
+  const url = bounded(string(image.url, "image URL", true), budget.maxRequestBytes, param);
+  const match = /^data:([^;,]+);base64,([\s\S]*)$/.exec(url);
+  if (!match || !["image/png", "image/jpeg", "image/webp"].includes(match[1]))
+    fail("unsupported_content", "Gemini images require inline PNG, JPEG or WebP data", param);
+  const data = match[2];
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(data) || data.length % 4 === 1 || data.includes("=") && data.length % 4 !== 0 || Buffer.from(data, "base64").toString("base64").replace(/=+$/, "") !== data.replace(/=+$/, ""))
+    fail("invalid_payload", "Invalid image Base64 encoding", param);
+  return { mimeType: match[1], data };
+}
+function geminiToolResponse(content, path, budget, diagnostics) {
+  if (!Array.isArray(content) || !content.some((part) => part.type === "image_url"))
+    return { response: { output: content } };
+  if (content.length > budget.maxItems)
+    fail("resource_limit", "Too many tool output parts", path);
+  const parts = [];
+  const output = content.map((part, index) => atParam(`${path}[${index}]`, () => {
+    if (part.type === "text")
+      return part;
+    if (part.type !== "image_url")
+      fail("unsupported_content", "Unsupported Gemini tool result content");
+    const image = record(part.image_url, "tool image");
+    const inlineData = geminiInlineImage(image, `${path}[${index}]`, budget);
+    const displayName = `tool-image-${index}.${inlineData.mimeType.slice("image/".length)}`;
+    parts.push({ inlineData: { ...inlineData, displayName } });
+    if (image.detail !== undefined)
+      diagnostics.push({ param: `${path}[${index}].detail`, action: "omitted", reason: "gemini_tool_image_detail_unavailable" });
+    return { $ref: displayName };
+  }));
+  return { response: { output }, parts };
+}
 function checkedSignature(value, maxBytes) {
   const signature = bounded(string(value, "thoughtSignature", true), maxBytes, "thoughtSignature");
   if (!/^[A-Za-z0-9+/]+={0,2}$/.test(signature) || signature.length % 4 === 1 || signature.includes("=") && signature.length % 4 !== 0 || Buffer.from(signature, "base64").toString("base64").replace(/=+$/, "") !== signature.replace(/=+$/, ""))
@@ -4815,7 +4854,31 @@ function validateCanonical(b, context) {
       for (const [j, part] of t.content.entries()) {
         const c = record(part, "part");
         fields2(c, c.type === "input_image" ? ["type", "image_url", "detail"] : c.type === "refusal" ? ["type", "refusal"] : ["type", "text", "annotations"], `${p}.content[${j}]`, "unsupported_content");
+        if (context.sourceProtocol === "responses" && context.targetProtocol === "gemini_generate_content" && t.role === "user" && c.type === "input_image") {
+          atParam(`${p}.content[${j}].image_url`, () => string(c.image_url, "image URL", true));
+          if (c.detail !== undefined && (typeof c.detail !== "string" || !["auto", "low", "high"].includes(c.detail)))
+            fail("unsupported_content", "Unknown image detail", `${p}.content[${j}].detail`);
+        }
       }
+    if (context.sourceProtocol === "responses" && context.targetProtocol === "gemini_generate_content" && Array.isArray(t.output))
+      for (const [j, part] of t.output.entries())
+        atParam(`${p}.output[${j}]`, () => {
+          const c = record(part, "tool output part");
+          fields2(c, c.type === "input_image" ? ["type", "image_url", "detail"] : ["type", "text", "annotations"], `${p}.output[${j}]`, "unsupported_content");
+          if (c.type === "input_image") {
+            atParam(`${p}.output[${j}].image_url`, () => string(c.image_url, "image URL", true));
+            if (c.detail !== undefined && (typeof c.detail !== "string" || !["auto", "low", "high"].includes(c.detail)))
+              fail("unsupported_content", "Unknown image detail", `${p}.output[${j}].detail`);
+          } else if (c.type === "input_text" || c.type === "output_text" || c.type === "text")
+            atParam(`${p}.output[${j}].text`, () => string(c.text, "tool output text"));
+          else
+            fail("unsupported_content", "Unsupported tool output content type", `${p}.output[${j}].type`);
+          if (c.annotations !== undefined)
+            atParam(`${p}.output[${j}].annotations`, () => {
+              if (list(c.annotations, "annotations").length)
+                fail("unsupported_content", "Output annotations cannot be represented in tool history");
+            });
+        });
   }
   const inspectTool = (raw, path, nested = false) => {
     const t = record(raw, "tool");
@@ -4848,6 +4911,7 @@ function validateCanonical(b, context) {
 }
 function convertProtocolRequest(raw, context) {
   const b = canonicalRequest(raw, context.sourceProtocol, context.model);
+  const originalInput = b.input;
   if (context.streaming !== undefined) {
     bool(context.streaming, "context.streaming");
     if (b.stream !== undefined && b.stream !== context.streaming)
@@ -4945,13 +5009,13 @@ function convertProtocolRequest(raw, context) {
   const decodingTarget = target === "gemini_generate_content" ? "chat_completions" : target;
   if (target === "gemini_generate_content" && reasoning)
     b.reasoning = { ...reasoning, effort: undefined };
-  const decoded = decodeResponsesRequest(b, decodingTarget, { ...cap, reasoningHistory: target !== "anthropic_messages" && cap.reasoningHistory === true, reasoningEffort: target === "chat_completions" && cap.reasoningEffort === true, anthropicThinkingBudget: undefined }, { preserveContentOrder: target === "gemini_generate_content" });
+  const decoded = decodeResponsesRequest(b, decodingTarget, { ...cap, reasoningHistory: target !== "anthropic_messages" && cap.reasoningHistory === true, reasoningEffort: target === "chat_completions" && cap.reasoningEffort === true, anthropicThinkingBudget: undefined }, { preserveContentOrder: target === "gemini_generate_content", toolOutputImages: context.sourceProtocol === "responses" && target === "gemini_generate_content" });
   const diagnostics = decoded.diagnostics;
   if (target === "gemini_generate_content" && decoded.body.parallel_tool_calls === true) {
     delete decoded.body.parallel_tool_calls;
     diagnostics.push({ param: "parallel_tool_calls", action: "omitted", reason: "gemini_parallel_tool_calls_allowed" });
   }
-  const body = target === "gemini_generate_content" ? renderGemini(decoded.body, context, geminiHistory?.parts, diagnostics) : decoded.body;
+  const body = target === "gemini_generate_content" ? renderGemini(decoded.body, context, originalInput, geminiHistory?.parts, diagnostics) : decoded.body;
   if (stop !== undefined)
     body[target === "chat_completions" ? "stop" : target === "anthropic_messages" ? "stop_sequences" : "generationConfig"] = target === "gemini_generate_content" ? { ...record(body.generationConfig ?? {}, "generationConfig"), stopSequences: typeof stop === "string" ? [stop] : stop } : typeof stop === "string" ? [stop] : stop;
   if (target === "anthropic_messages") {
@@ -4988,9 +5052,19 @@ function convertProtocolRequest(raw, context) {
     diagnostics.push({ param: "reasoning", action: "mapped", reason: "explicit_verified_wire_policy" });
   return { body, canonicalHistory: geminiHistory?.canonicalHistory(decoded.canonicalInput) ?? decoded.canonicalInput, diagnostics, toolNames: decoded.toolNames, streaming: b.stream === true };
 }
-function renderGemini(chat, context, signedParts, diagnostics) {
+function renderGemini(chat, context, input, signedParts, diagnostics) {
   const result = { contents: [] }, contents = result.contents, system = [], calls = new Map;
   const nativeIds = new Set;
+  const budget = limits(context.capabilities?.limits);
+  const toolOutputParams = new Map;
+  const userMessageParams = [];
+  let userMessageIndex = 0;
+  for (const [index, item] of (Array.isArray(input) ? input : []).entries()) {
+    if (item.type === "function_call_output" || item.type === "custom_tool_call_output")
+      toolOutputParams.set(item.call_id, `input[${index}].output`);
+    if ((item.type === undefined || item.type === "message") && item.role === "user" || item.type === "agent_message")
+      userMessageParams.push(`input[${index}].content`);
+  }
   const append = (role, parts) => {
     const prev = contents.at(-1);
     if (prev?.role === role)
@@ -5004,10 +5078,33 @@ function renderGemini(chat, context, signedParts, diagnostics) {
       append("model", signed);
       continue;
     }
-    const parts = m.content == null ? [] : typeof m.content === "string" ? [{ text: m.content }] : m.content.map((p) => {
-      if (p.type !== "text")
-        fail("unsupported_content", "This content cannot cross to Gemini", "input");
-      return { text: p.text };
+    if (m.role === "tool") {
+      const name = calls.get(string(m.tool_call_id, "tool_call_id"));
+      if (!name)
+        fail("invalid_tool_history", "Unknown tool result", "input");
+      if (m.is_error === true)
+        fail("unsupported_content", "Tool error authority cannot be represented by Gemini", "input");
+      const { id } = context.sourceProtocol === "responses" ? decodeGeminiCallId(m.tool_call_id, budget.maxArgumentBytes) : { id: m.tool_call_id };
+      const response = geminiToolResponse(m.content, toolOutputParams.get(m.tool_call_id) ?? "input", budget, diagnostics);
+      append("user", [{ functionResponse: { id, name, ...response } }]);
+      continue;
+    }
+    const contentParam = m.role === "user" ? userMessageParams[userMessageIndex++] ?? "input" : "input";
+    if (Array.isArray(m.content) && m.content.some((p) => p.type === "image_url") && m.content.length > budget.maxItems)
+      fail("resource_limit", "Too many message content parts", contentParam);
+    const parts = m.content == null ? [] : typeof m.content === "string" ? [{ text: m.content }] : m.content.map((p, index) => {
+      if (p.type === "text")
+        return { text: p.text };
+      const path = `${contentParam}[${index}]`;
+      if (context.sourceProtocol !== "responses" || m.role !== "user" || p.type !== "image_url")
+        fail("unsupported_content", "This content cannot cross to Gemini", contentParam);
+      const image = record(p.image_url, "image"), part = { inlineData: geminiInlineImage(image, path, budget) };
+      if (image.detail === "low" || image.detail === "high") {
+        part.mediaResolution = { level: image.detail === "high" ? "MEDIA_RESOLUTION_HIGH" : "MEDIA_RESOLUTION_LOW" };
+        diagnostics.push({ param: `${path}.detail`, action: "mapped", reason: "gemini_image_media_resolution" });
+      } else if (image.detail === "auto")
+        diagnostics.push({ param: `${path}.detail`, action: "omitted", reason: "gemini_image_detail_auto" });
+      return part;
     });
     if (m.role === "system" || m.role === "developer") {
       if (contents.length) {
@@ -5018,16 +5115,6 @@ function renderGemini(chat, context, signedParts, diagnostics) {
       system.push(...parts);
       continue;
     }
-    if (m.role === "tool") {
-      const name = calls.get(string(m.tool_call_id, "tool_call_id"));
-      if (!name)
-        fail("invalid_tool_history", "Unknown tool result", "input");
-      if (m.is_error === true)
-        fail("unsupported_content", "Tool error authority cannot be represented by Gemini", "input");
-      const { id } = context.sourceProtocol === "responses" ? decodeGeminiCallId(m.tool_call_id, limits(context.capabilities?.limits).maxArgumentBytes) : { id: m.tool_call_id };
-      append("user", [{ functionResponse: { id, name, response: { output: m.content } } }]);
-      continue;
-    }
     if (m.reasoning_content !== undefined)
       parts.unshift({ text: m.reasoning_content, thought: true });
     for (const c of m.tool_calls ?? []) {
@@ -6732,4 +6819,4 @@ export {
   control_default as default
 };
 
-//# debugId=165F7F1DADB9687864756E2164756E21
+//# debugId=529D4667BD09A6C364756E2164756E21