@jeffusion/bungee-core 6.11.1 → 6.11.3

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

@@ -3631,6 +3631,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
   const callIds = new Set;
   const callToolNames = new Map;
   const answered = new Set;
+  const deferredInstructions = [];
+  const normalizeChatHistory = protocol === "chat_completions" && !options.preserveContentOrder;
   const projectedToolImages = [];
   let pendingReasoning = "";
   const addMessage = (message) => {
@@ -3656,6 +3658,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
         flushToolImages();
       if (item.type === "additional_tools")
         return;
+      if (deferredInstructions.length && item.type !== "function_call_output" && item.type !== "custom_tool_call_output" && !((item.type === undefined || item.type === "message") && (item.role === "system" || item.role === "developer")))
+        fail("invalid_tool_history", "Only instructions and tool results may follow a deferred instruction until all tool results arrive", messageParam);
       if (item.type === "agent_message") {
         validateAgentMessage(item, messageParam, capabilities.limits);
         if (capabilities.agentMessageDelivery !== "plaintext")
@@ -3734,6 +3738,13 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
           }
         }
         addMessage({ role: "tool", tool_call_id: id, content: output, ...item.is_error === true ? { is_error: true } : {} });
+        if (callIds.size === answered.size) {
+          for (const instruction of deferredInstructions) {
+            messageParam = instruction.param;
+            addMessage(instruction.message);
+          }
+          deferredInstructions.length = 0;
+        }
         return;
       }
       if (item.type !== undefined && item.type !== "message")
@@ -3750,6 +3761,11 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
         message.reasoning_content = pendingReasoning;
         pendingReasoning = "";
       }
+      if (normalizeChatHistory && (role === "system" || role === "developer") && callIds.size !== answered.size) {
+        deferredInstructions.push({ message, param: messageParam });
+        diagnostics.push({ param: messageParam, action: "mapped", reason: "chat_instruction_deferred_until_tool_results" });
+        return;
+      }
       if (protocol === "chat_completions" && !options.preserveContentOrder && role === "assistant") {
         const previous = chat.at(-1);
         if (previous?.role === "assistant") {
@@ -3763,6 +3779,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
     });
   if (pendingReasoning)
     fail("unsupported_reasoning", "Orphan reasoning history cannot be represented");
+  if (deferredInstructions.length)
+    fail("invalid_tool_history", "Deferred instructions require all pending tool results", deferredInstructions[0].param);
   flushToolImages(true);
   const result = { model, messages: chat };
   const omittedAllTools = !tools.length && diagnostics.some((item) => item.reason === "optional_hosted_web_search_unavailable");
@@ -3866,6 +3884,28 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {})
   return { body: result, toolNames, canonicalInput, diagnostics };
 }
 // packages/llms/src/responses-codec/events.ts
+function chatOutput(raw) {
+  const keys = ["role", "content", "refusal", "reasoning_content", "reasoning", "tool_calls", "function_call", "annotations"];
+  const delta = Object.fromEntries(keys.filter((key) => raw[key] != null).map((key) => [key, raw[key]]));
+  const provider = raw.provider_specific_fields == null ? {} : record(raw.provider_specific_fields, "provider_specific_fields");
+  for (const key of ["refusal", "reasoning_content", "reasoning"]) {
+    if (provider[key] == null)
+      continue;
+    if (delta[key] != null && delta[key] !== provider[key])
+      fail("unsupported_content", "Conflicting provider output fields", `provider_specific_fields.${key}`);
+    delta[key] = provider[key];
+  }
+  for (const key of ["audio", "thinking_blocks", "reasoning_details", "signature", "thought_signature", "thoughtSignature", "encrypted_content", "encrypted_function_args"])
+    if (raw[key] != null || provider[key] != null)
+      fail("unsupported_content", "Provider output authority cannot cross protocols", key);
+  for (const key of ["content", "tool_calls", "function_call", "annotations"])
+    if (provider[key] != null)
+      fail("unsupported_content", "Nested provider output cannot cross protocols", `provider_specific_fields.${key}`);
+  if (delta.reasoning_content != null && delta.reasoning != null && delta.reasoning_content !== delta.reasoning)
+    fail("unsupported_content", "Conflicting reasoning fields", "reasoning");
+  return delta;
+}
+
 class ResponsesEventEncoder {
   protocol;
   model;
@@ -4075,10 +4115,7 @@ class ResponsesEventEncoder {
       const choice = record(choices[0], "choice");
       if (choice.index !== undefined && choice.index !== 0)
         fail("unsupported_response", "Only choice index 0 is supported");
-      const delta = record(choice.delta ?? {}, "choice delta");
-      for (const key of Object.keys(delta))
-        if (!["role", "content", "refusal", "reasoning_content", "reasoning", "tool_calls", "function_call", "annotations"].includes(key))
-          fail("unsupported_content", `Unsupported Chat output field ${key}`);
+      const delta = chatOutput(record(choice.delta ?? {}, "choice delta"));
       if (delta.annotations !== undefined && list(delta.annotations, "annotations").length)
         fail("unsupported_content", "Chat output annotations cannot be faithfully converted");
       if (delta.role !== undefined && delta.role !== "assistant")
@@ -4276,7 +4313,7 @@ function encodeResponsesResult(raw, protocol, model, toolNames = new Map, config
     const choice = record(choices[0], "choice");
     const message = record(choice.message, "message");
     const delta = { ...message };
-    if (message.tool_calls !== undefined)
+    if (message.tool_calls != null)
       delta.tool_calls = list(message.tool_calls, "tool_calls").map((tool, index) => ({ ...record(tool, "tool call"), index }));
     encoder.push({ choices: [{ index: choice.index ?? 0, delta, finish_reason: choice.finish_reason }], usage: body.usage });
   } else {
@@ -5006,7 +5043,7 @@ function convertProtocolRequest(raw, context) {
       fail("unsupported_reasoning", "Source thinking mode needs an explicit target wire policy", "thinking");
   }
   if (target === "responses") {
-    const validation = decodeResponsesRequest({ ...b, reasoning: reasoning ? { ...reasoning, effort: undefined } : undefined }, "chat_completions", { ...cap, reasoningHistory: true });
+    const validation = decodeResponsesRequest({ ...b, reasoning: reasoning ? { ...reasoning, effort: undefined } : undefined }, "chat_completions", { ...cap, reasoningHistory: true }, { preserveContentOrder: true, toolOutputImages: true });
     if (mappedEffort !== undefined)
       b.reasoning = { ...reasoning, effort: mappedEffort };
     else if (reasoning?.effort !== undefined)
@@ -5265,20 +5302,14 @@ function validateProviderResponse(raw, protocol) {
   if (b.error !== undefined || b.type === "error")
     return b;
   if (protocol === "chat_completions") {
-    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", "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.provider_specific_fields != null)
+        record(c.provider_specific_fields, "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 [callIndex, rawCall] of (m.tool_calls === undefined ? [] : list(m.tool_calls, "tool_calls")).entries()) {
+      for (const [callIndex, rawCall] of (m.tool_calls == null ? [] : list(m.tool_calls, "tool_calls")).entries()) {
         const call = record(rawCall, "call");
         fields2(call, ["id", "type", "function", "index"], "tool_calls", "unsupported_tool");
         if (call.index !== undefined && integer(call.index, `tool_calls[${callIndex}].index`) !== callIndex)
@@ -5288,7 +5319,6 @@ function validateProviderResponse(raw, protocol) {
     }
     validateUsage(b.usage, protocol);
   } else if (protocol === "anthropic_messages") {
-    fields2(b, ["id", "type", "role", "model", "content", "stop_reason", "stop_sequence", "usage"], "", "unsupported_response");
     if (b.role !== undefined && b.role !== "assistant")
       fail("unsupported_response", "Response role must be assistant", "role");
     for (const rawPart of list(b.content, "content"))
@@ -5494,7 +5524,6 @@ class GeminiCanonicalDecoder {
   }
   push(raw) {
     const b = record(raw, "Gemini response");
-    fields2(b, ["candidates", "usageMetadata", "modelVersion", "responseId", "promptFeedback", "error"], "", "unsupported_response");
     if (b.error !== undefined)
       return this.decorate(this.encoder.push({ error: safeProtocolError() }));
     const events = [];
@@ -5511,7 +5540,6 @@ class GeminiCanonicalDecoder {
       fail("unsupported_response", "Multiple Gemini candidates cannot cross protocols", "candidates");
     if (candidates.length) {
       const c = record(candidates[0], "candidate");
-      fields2(c, ["index", "content", "finishReason", "safetyRatings", "finishMessage"], "candidates", "unsupported_response");
       if (c.index !== undefined && c.index !== 0)
         fail("unsupported_response", "Only candidate index zero is supported", "candidates.index");
       if (c.content !== undefined && c.content !== null) {
@@ -6117,9 +6145,9 @@ function createProtocolSession(context) {
           fail("invalid_session", "A session can convert one JSON response or one stream");
         mode = "json";
         finished = true;
+        const body = record(raw, "response");
+        serialized(body, limits(context.capabilities?.limits).maxOutputBytes, "response");
         if (same) {
-          const body = record(raw, "response");
-          serialized(body, limits(context.capabilities?.limits).maxOutputBytes, "response");
           return body;
         }
         const canonical = canonicalResponse(raw, context, names);
@@ -6133,9 +6161,9 @@ function createProtocolSession(context) {
         if (finished || mode === "json")
           fail("invalid_stream", "Event arrived after session completion");
         mode = "stream";
+        const e = record(raw, "event");
+        serialized(e, limits(context.capabilities?.limits).maxOutputBytes, "event");
         if (same) {
-          const e = record(raw, "event");
-          serialized(e, limits(context.capabilities?.limits).maxOutputBytes, "event");
           if (context.targetProtocol === "anthropic_messages") {
             if (passAnthropicStopped)
               fail("invalid_stream", "Event arrived after message_stop");
@@ -6213,11 +6241,11 @@ function validateStreamEnvelope(raw, protocol) {
   if (e.error !== undefined || e.type === "error")
     return;
   if (protocol === "chat_completions") {
-    fields2(e, ["id", "object", "created", "model", "choices", "usage", "system_fingerprint", "service_tier"], "", "unsupported_response");
     if (Array.isArray(e.choices))
       for (const rawChoice of e.choices) {
         const c = record(rawChoice, "choice");
-        fields2(c, ["index", "delta", "finish_reason", "logprobs"], "choices", "unsupported_response");
+        if (c.provider_specific_fields != null)
+          record(c.provider_specific_fields, "choices.provider_specific_fields");
         if (c.logprobs != null)
           fail("unsupported_response", "Log probabilities cannot cross protocols", "choices.logprobs");
         const d = record(c.delta ?? {}, "delta");
@@ -6231,8 +6259,6 @@ function validateStreamEnvelope(raw, protocol) {
       }
     validateUsage(e.usage, protocol);
   } else {
-    const allowed = e.type === "message_start" ? ["type", "message"] : e.type === "message_delta" ? ["type", "delta", "usage"] : e.type === "content_block_start" ? ["type", "index", "content_block"] : e.type === "content_block_delta" ? ["type", "index", "delta"] : e.type === "content_block_stop" ? ["type", "index"] : ["type"];
-    fields2(e, allowed, "", "unsupported_response");
     if (e.type === "content_block_start")
       validateAnthropicBlock(record(e.content_block, "block"), "content_block");
     if (e.type === "content_block_delta") {
@@ -6245,7 +6271,6 @@ function validateStreamEnvelope(raw, protocol) {
       fields2(record(e.delta, "delta"), ["stop_reason", "stop_sequence"], "delta", "unsupported_response");
     if (e.type === "message_start") {
       const m = record(e.message, "message");
-      fields2(m, ["id", "type", "role", "model", "content", "stop_reason", "stop_sequence", "usage"], "message", "unsupported_response");
       validateUsage(m.usage, protocol);
       if (m.content !== undefined && (!Array.isArray(m.content) || m.content.length))
         fail("unsupported_content", "Initial stream message content must be empty", "message.content");
@@ -6877,4 +6902,4 @@ export {
   control_default as default
 };
 
-//# debugId=C05F1FFA2AD4DDAA64756E2164756E21
+//# debugId=6F3A86A34BE6620564756E2164756E21