@jeffusion/bungee-core 6.7.3 → 6.8.1

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

@@ -3379,7 +3379,7 @@ function definitionKey(value) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${definitionKey(value[key])}`).join(",")}}`;
   return JSON.stringify(value);
 }
-function decodeResponsesRequest(raw, protocol, capabilities = {}) {
+function decodeResponsesRequest(raw, protocol, capabilities = {}, options = {}) {
   const body = record(raw, "Responses request");
   if (capabilities.agentMessageDelivery !== undefined && capabilities.agentMessageDelivery !== "plaintext")
     fail("invalid_payload", "Unknown agent message delivery policy", "agentMessageDelivery");
@@ -3646,12 +3646,16 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
         if (item.content != null)
           fail("unsupported_reasoning", "Reasoning content requires an explicit history mapping", `${messageParam}.content`);
         const summary = list(item.summary, "reasoning summary");
-        pendingReasoning += summary.map((part) => {
+        const text = summary.map((part) => {
           const p = record(part, "reasoning summary");
           if (p.type !== "summary_text")
             fail("unsupported_reasoning", "Unknown reasoning summary");
           return string(p.text, "summary text");
         }).join("");
+        if (options.preserveContentOrder)
+          addMessage({ role: "assistant", content: null, reasoning_content: text, ...item.id === undefined ? {} : { id: string(item.id, "item.id", true) } });
+        else
+          pendingReasoning += text;
         return;
       }
       if (item.type === "function_call" || item.type === "custom_tool_call") {
@@ -3666,7 +3670,7 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
         argumentObject(args);
         const call = { id, type: "function", function: { name: resolve(item, custom), arguments: args } };
         const previous = chat.at(-1);
-        if (previous?.role === "assistant") {
+        if (previous?.role === "assistant" && !options.preserveContentOrder) {
           previous.tool_calls = [...previous.tool_calls ?? [], call];
           if (pendingReasoning)
             previous.reasoning_content = pendingReasoning;
@@ -3690,6 +3694,8 @@ function decodeResponsesRequest(raw, protocol, capabilities = {}) {
       if (!["user", "assistant", "system", "developer"].includes(role))
         fail("unsupported_content", "Unknown message role");
       const message = { role, content: normalizeContent(item.content, role) };
+      if (options.preserveContentOrder && item.id !== undefined)
+        message.id = string(item.id, "item.id", true);
       if (pendingReasoning) {
         if (role !== "assistant")
           fail("unsupported_reasoning", "Reasoning must precede an assistant item");
@@ -4230,6 +4236,9 @@ function encodeResponsesResult(raw, protocol, model, toolNames = new Map, config
     fail("missing_terminal", "JSON response has no terminal result");
   return record(end.response, "Responses result");
 }
+// packages/llms/src/protocol-session/gemini.ts
+import { createHash } from "crypto";
+
 // packages/llms/src/protocol-session/validation.ts
 function fields2(value, allowed, path, code = "unsupported_request") {
   for (const key of Object.keys(value))
@@ -4274,6 +4283,145 @@ function textParts(raw, path, style, role) {
   });
 }
 
+// packages/llms/src/protocol-session/gemini.ts
+var signatureSeparator = "__thought__";
+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(/=+$/, ""))
+    fail("invalid_tool_arguments", "Invalid Gemini thought signature encoding", "thoughtSignature");
+  return signature;
+}
+var envelopePrefix = "bungee_gemini:";
+var geminiEnvelopeBytes = (payloadBytes) => envelopePrefix.length + Math.ceil(payloadBytes * 4 / 3);
+var geminiTextHash = (text) => createHash("sha256").update(text).digest("base64url");
+function geminiSignatureItem(items, budget) {
+  const payload = serialized({ version: 1, items }, budget.maxArgumentBytes, "Gemini signatures");
+  return {
+    type: "reasoning",
+    id: `rs_gemini_${crypto.randomUUID().replaceAll("-", "")}`,
+    summary: [],
+    encrypted_content: bounded(envelopePrefix + Buffer.from(payload).toString("base64url"), budget.maxArgumentBytes, "Gemini signatures")
+  };
+}
+function readGeminiSignatures(item, budget) {
+  fields2(item, ["type", "id", "summary", "encrypted_content", "status"], "Gemini signatures", "unsupported_reasoning");
+  if (item.type !== "reasoning" || list(item.summary, "summary").length)
+    fail("unsupported_reasoning", "Invalid Gemini signature carrier");
+  string(item.id, "signature item id", true);
+  const opaque = bounded(string(item.encrypted_content, "encrypted_content", true), budget.maxArgumentBytes, "Gemini signatures");
+  if (!opaque.startsWith(envelopePrefix))
+    fail("unsupported_reasoning", "Native encrypted reasoning cannot be restored to Gemini");
+  const encoded = opaque.slice(envelopePrefix.length), bytes = Buffer.from(encoded, "base64url");
+  if (!encoded || bytes.toString("base64url") !== encoded)
+    fail("unsupported_reasoning", "Invalid Gemini signature carrier encoding");
+  let raw;
+  try {
+    raw = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    fail("unsupported_reasoning", "Invalid Gemini signature carrier JSON");
+  }
+  const body = record(raw, "Gemini signatures");
+  fields2(body, ["version", "items"], "Gemini signatures", "unsupported_reasoning");
+  if (body.version !== 1)
+    fail("unsupported_reasoning", "Unknown Gemini signature format");
+  const ids = new Set;
+  let partCount = 0;
+  const result = list(body.items, "signature items").map((raw) => {
+    const item = record(raw, "signature item");
+    fields2(item, ["id", "thought", "parts"], "signature item", "unsupported_reasoning");
+    const id = string(item.id, "signed item id", true);
+    if (ids.has(id) || typeof item.thought !== "boolean")
+      fail("unsupported_reasoning", "Invalid signed item identity");
+    ids.add(id);
+    const parts = list(item.parts, "signed parts").map((raw) => {
+      if (++partCount > budget.maxItems)
+        fail("resource_limit", "Too many signed Gemini parts");
+      const part = record(raw, "signed part");
+      fields2(part, ["length", "hash", "signature", "textAbsent"], "signed part", "unsupported_reasoning");
+      const length = integer(part.length, "signed part length"), hash = string(part.hash, "signed part hash", true);
+      if (!/^[A-Za-z0-9_-]{43}$/.test(hash))
+        fail("unsupported_reasoning", "Invalid signed part hash");
+      const signature = part.signature === undefined ? undefined : checkedSignature(part.signature, budget.maxArgumentBytes);
+      if (part.textAbsent !== undefined && (part.textAbsent !== true || length !== 0 || signature === undefined))
+        fail("unsupported_reasoning", "Invalid empty signed part");
+      return { length, hash, ...signature === undefined ? {} : { signature }, ...part.textAbsent ? { textAbsent: true } : {} };
+    });
+    if (!parts.some((p) => p.signature !== undefined))
+      fail("unsupported_reasoning", "Signature carrier has no signature");
+    return { id, thought: item.thought, parts };
+  });
+  if (!result.length || result.length > budget.maxItems)
+    fail("unsupported_reasoning", "Invalid signature item count");
+  return result;
+}
+function restoreGeminiHistory(input, budget) {
+  const original = typeof input === "string" ? [] : list(input, "input").map((raw) => record(raw, "input item"));
+  const carriers = new Set, parts = new Map, ids = new Map;
+  original.forEach((item, i) => {
+    if (typeof item.id === "string") {
+      if (ids.has(item.id))
+        fail("invalid_tool_history", "Duplicate history item id", "input.id");
+      ids.set(item.id, i);
+    }
+  });
+  original.forEach((carrier, index) => {
+    if (carrier.encrypted_content == null)
+      return;
+    const signed = readGeminiSignatures(carrier, budget);
+    carriers.add(carrier);
+    let previous = -1;
+    for (const item of signed) {
+      const at = ids.get(item.id);
+      if (at === undefined || at >= index || at <= previous || parts.has(item.id))
+        fail("unsupported_reasoning", "Signed history reference is missing or ambiguous");
+      previous = at;
+      const source = original[at];
+      if (item.thought ? source.type !== "reasoning" || source.encrypted_content != null : source.role !== "assistant" || source.type !== undefined && source.type !== "message")
+        fail("unsupported_reasoning", "Signed history item kind changed");
+      const content = item.thought ? list(source.summary, "summary") : typeof source.content === "string" ? [{ type: "output_text", text: source.content }] : list(source.content, "content");
+      const text = content.map((raw) => {
+        const p = record(raw, "signed text");
+        if (p.type !== (item.thought ? "summary_text" : "output_text") && !(p.type === "input_text" && !item.thought))
+          fail("unsupported_reasoning", "Signed history content kind changed");
+        return string(p.text, "signed text");
+      }).join("");
+      let offset = 0;
+      const restored = item.parts.map((part) => {
+        const value = text.slice(offset, offset + part.length);
+        offset += part.length;
+        if (value.length !== part.length || geminiTextHash(value) !== part.hash)
+          fail("unsupported_reasoning", "Signed history text changed");
+        return { ...part.textAbsent ? {} : { text: value }, ...item.thought ? { thought: true } : {}, ...part.signature === undefined ? {} : { thoughtSignature: part.signature } };
+      });
+      if (offset !== text.length)
+        fail("unsupported_reasoning", "Signed history text was not fully consumed");
+      parts.set(item.id, restored);
+    }
+  });
+  return {
+    input: typeof input === "string" ? input : original.filter((item) => !carriers.has(item)),
+    parts,
+    canonicalHistory(decoded) {
+      if (!carriers.size)
+        return decoded;
+      let next = 0;
+      return original.flatMap((item) => carriers.has(item) ? [item] : item.type === "additional_tools" ? [] : [decoded[next++]]);
+    }
+  };
+}
+function encodeGeminiCallId(id, signature, maxBytes) {
+  if (id.includes(signatureSeparator))
+    fail("invalid_tool_arguments", "Gemini call id contains the signature separator", "functionCall.id");
+  return signature === undefined ? id : `${id}${signatureSeparator}${checkedSignature(signature, maxBytes)}`;
+}
+function decodeGeminiCallId(value, maxBytes) {
+  const separator = value.indexOf(signatureSeparator);
+  if (separator < 0)
+    return { id: value };
+  const id = string(value.slice(0, separator), "functionCall.id", true);
+  return { id, thoughtSignature: checkedSignature(value.slice(separator + signatureSeparator.length), maxBytes) };
+}
+
 // packages/llms/src/protocol-session/schema.ts
 function geminiSchemaToJson(raw, path, code = "unsupported_request", depth = 0) {
   if (depth > 64)
@@ -4707,6 +4855,9 @@ function convertProtocolRequest(raw, context) {
     b.stream = context.streaming;
   }
   validateCanonical(b, context);
+  const geminiHistory = context.sourceProtocol === "responses" && context.targetProtocol === "gemini_generate_content" ? restoreGeminiHistory(b.input, limits(context.capabilities?.limits)) : undefined;
+  if (geminiHistory)
+    b.input = geminiHistory.input;
   const cap = { ...context.capabilities, agentMessageDelivery: context.agentMessageDelivery ?? context.capabilities?.agentMessageDelivery, omitOptionalWebSearch: true, preserveToolIdentityDescription: true, preserveRefusalContent: true }, policy = context.reasoningPolicy;
   const reasoning = b.reasoning === undefined ? undefined : record(b.reasoning, "reasoning");
   const sourceThinking = b.sourceThinking;
@@ -4732,10 +4883,10 @@ function convertProtocolRequest(raw, context) {
   if (sourceThinking !== undefined && reasoning?.effort === undefined && policy?.targetEffort !== undefined)
     mappedEffort = string(policy.targetEffort, "reasoningPolicy.targetEffort", true);
   const target = context.targetProtocol;
-  if (target === "gemini_generate_content" && reasoning?.effort !== undefined && policy?.geminiThinkingBudget === undefined && policy?.geminiThinkingLevel === undefined)
+  if (target === "gemini_generate_content" && reasoning?.effort !== undefined && mappedEffort === undefined && policy?.geminiThinkingBudget === undefined && policy?.geminiThinkingLevel === undefined)
     fail("unsupported_reasoning", "Gemini requires an explicit thinking budget or level", "reasoning.effort");
   if (sourceThinking !== undefined) {
-    const represented = target === "responses" || target === "chat_completions" ? mappedEffort !== undefined : target === "anthropic_messages" ? mappedEffort !== undefined || policy?.anthropicThinkingMode !== undefined || policy?.anthropicThinkingBudget !== undefined : policy?.geminiThinkingBudget !== undefined || policy?.geminiThinkingLevel !== undefined;
+    const represented = target === "responses" || target === "chat_completions" ? mappedEffort !== undefined : target === "anthropic_messages" ? mappedEffort !== undefined || policy?.anthropicThinkingMode !== undefined || policy?.anthropicThinkingBudget !== undefined : mappedEffort !== undefined || policy?.geminiThinkingBudget !== undefined || policy?.geminiThinkingLevel !== undefined;
     if (!represented)
       fail("unsupported_reasoning", "Source thinking mode needs an explicit target wire policy", "thinking");
   }
@@ -4794,9 +4945,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 });
+  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 diagnostics = decoded.diagnostics;
-  const body = target === "gemini_generate_content" ? renderGemini(decoded.body, cap.geminiJsonSchema === true) : decoded.body;
+  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;
   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") {
@@ -4818,18 +4973,24 @@ function convertProtocolRequest(raw, context) {
       body.thinking = { type: "enabled", budget_tokens: budget };
     }
   }
-  if (target === "gemini_generate_content" && (policy?.geminiThinkingBudget !== undefined || policy?.geminiThinkingLevel !== undefined)) {
-    if (policy.geminiThinkingBudget !== undefined && policy.geminiThinkingLevel !== undefined)
+  if (target === "gemini_generate_content" && (mappedEffort !== undefined || policy?.geminiThinkingBudget !== undefined || policy?.geminiThinkingLevel !== undefined)) {
+    const level = policy?.geminiThinkingLevel ?? mappedEffort;
+    if (policy?.geminiThinkingBudget !== undefined && level !== undefined)
       fail("unsupported_reasoning", "Choose one Gemini thinking policy", "reasoningPolicy");
-    const thinkingConfig = policy.geminiThinkingBudget !== undefined ? { thinkingBudget: integer(policy.geminiThinkingBudget, "reasoningPolicy.geminiThinkingBudget", -1) } : { thinkingLevel: string(policy.geminiThinkingLevel, "reasoningPolicy.geminiThinkingLevel", true) };
+    if (level !== undefined && !["minimal", "low", "medium", "high"].includes(level))
+      fail("unsupported_reasoning", "Unknown Gemini thinking level", "reasoning.effort");
+    if (mappedEffort !== undefined && policy?.geminiThinkingLevel !== undefined && mappedEffort !== policy.geminiThinkingLevel)
+      fail("unsupported_reasoning", "Conflicting Gemini thinking levels", "reasoning.effort");
+    const thinkingConfig = policy?.geminiThinkingBudget !== undefined ? { thinkingBudget: integer(policy.geminiThinkingBudget, "reasoningPolicy.geminiThinkingBudget", -1) } : { thinkingLevel: string(level, "reasoningPolicy.geminiThinkingLevel", true) };
     body.generationConfig = { ...record(body.generationConfig ?? {}, "generationConfig"), thinkingConfig };
   }
   if (mappedEffort !== undefined || sourceThinking !== undefined || policy?.anthropicThinkingBudget !== undefined)
     diagnostics.push({ param: "reasoning", action: "mapped", reason: "explicit_verified_wire_policy" });
-  return { body, canonicalHistory: decoded.canonicalInput, diagnostics, toolNames: decoded.toolNames, streaming: b.stream === true };
+  return { body, canonicalHistory: geminiHistory?.canonicalHistory(decoded.canonicalInput) ?? decoded.canonicalInput, diagnostics, toolNames: decoded.toolNames, streaming: b.stream === true };
 }
-function renderGemini(chat, jsonSchema) {
+function renderGemini(chat, context, signedParts, diagnostics) {
   const result = { contents: [] }, contents = result.contents, system = [], calls = new Map;
+  const nativeIds = new Set;
   const append = (role, parts) => {
     const prev = contents.at(-1);
     if (prev?.role === role)
@@ -4838,14 +4999,22 @@ function renderGemini(chat, jsonSchema) {
       contents.push({ role, parts });
   };
   for (const m of chat.messages) {
+    const signed = signedParts?.get(m.id);
+    if (signed) {
+      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 === "system" || m.role === "developer") {
-      if (contents.length)
-        fail("unsupported_content", "Mid-conversation instructions cannot be relocated", "input");
+      if (contents.length) {
+        if (context.sourceProtocol !== "responses")
+          fail("unsupported_content", "Mid-conversation instructions cannot be relocated", "input");
+        diagnostics.push({ param: "input", action: "mapped", reason: "gemini_mid_conversation_instructions_consolidated" });
+      }
       system.push(...parts);
       continue;
     }
@@ -4855,7 +5024,8 @@ function renderGemini(chat, jsonSchema) {
         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");
-      append("user", [{ functionResponse: { id: m.tool_call_id, name, response: { output: m.content } } }]);
+      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)
@@ -4863,10 +5033,20 @@ function renderGemini(chat, jsonSchema) {
     for (const c of m.tool_calls ?? []) {
       const fn = record(c.function, "function");
       calls.set(c.id, fn.name);
-      parts.push({ functionCall: { id: c.id, name: fn.name, args: argumentObject(fn.arguments) } });
+      const { id, thoughtSignature } = context.sourceProtocol === "responses" ? decodeGeminiCallId(c.id, limits(context.capabilities?.limits).maxArgumentBytes) : { id: c.id, thoughtSignature: undefined };
+      if (nativeIds.has(id))
+        fail("invalid_tool_history", "Duplicate decoded Gemini call id", "call_id");
+      nativeIds.add(id);
+      parts.push({ functionCall: { id, name: fn.name, args: argumentObject(fn.arguments) }, ...thoughtSignature === undefined ? {} : { thoughtSignature } });
     }
     append(m.role === "assistant" ? "model" : "user", parts);
   }
+  if (chat.parallel_tool_calls !== undefined) {
+    if (context.sourceProtocol !== "responses" || chat.parallel_tool_calls !== false)
+      fail("unsupported_request", "Gemini cannot enforce parallel tool preference", "parallel_tool_calls");
+    system.push({ text: "Call at most one tool per response." });
+    diagnostics.push({ param: "parallel_tool_calls", action: "mapped", reason: "gemini_serial_tool_calls_prompt_only" });
+  }
   if (system.length)
     result.systemInstruction = { parts: system };
   const generation = {};
@@ -4875,12 +5055,10 @@ function renderGemini(chat, jsonSchema) {
       generation[to] = chat[from];
   if (chat.metadata !== undefined)
     fail("unsupported_request", "Gemini has no compatible request metadata", "metadata");
-  if (chat.parallel_tool_calls !== undefined)
-    fail("unsupported_request", "Gemini cannot enforce parallel tool preference", "parallel_tool_calls");
   if (chat.response_format !== undefined) {
     const f = record(chat.response_format, "format");
     if (f.type === "json_schema") {
-      if (!jsonSchema)
+      if (!context.capabilities?.geminiJsonSchema)
         fail("unsupported_request", "Target JSON schema capability is required", "text.format");
       const s = record(f.json_schema, "schema");
       if (s.strict === false)
@@ -5025,7 +5203,11 @@ function validateCanonicalResponse(raw, context, itemOnly = false) {
           fail("unsupported_content", "Output annotations cannot cross protocols", path);
       }
     } else if (t.type === "reasoning") {
-      if (t.encrypted_content != null || t.content != null)
+      if (t.encrypted_content != null && context.sourceProtocol === "responses" && context.targetProtocol === "gemini_generate_content")
+        readGeminiSignatures(t, limits(context.capabilities?.limits));
+      else if (t.encrypted_content != null)
+        fail("unsupported_reasoning", "Opaque reasoning cannot cross protocols", path);
+      if (t.content != null)
         fail("unsupported_reasoning", "Opaque or raw reasoning output cannot cross protocols", path);
       for (const rawPart of list(t.summary, "summary")) {
         const p = record(rawPart, "summary");
@@ -5148,20 +5330,28 @@ function responseFromCanonical(raw, protocol, context) {
 
 class GeminiCanonicalDecoder {
   context;
+  streaming;
   encoder;
   serial = 0;
   ended = false;
   tools = false;
   ids = new Set;
-  constructor(context, names) {
+  sequence = 0;
+  contentId;
+  partCount = 0;
+  replayBytes = Buffer.byteLength(JSON.stringify({ version: 1, items: [] }));
+  signedItems = 0;
+  signed = new Map;
+  constructor(context, names, streaming = true) {
     this.context = context;
-    this.encoder = new ResponsesEventEncoder("chat_completions", context.responseModel ?? context.model, names, context.capabilities?.limits, { preserveContentOrder: true });
+    this.streaming = streaming;
+    this.encoder = new ResponsesEventEncoder("chat_completions", context.responseModel ?? context.model, names, context.capabilities?.limits, { preserveContentOrder: true, agentMessageDelivery: context.capabilities?.agentMessageDelivery });
   }
   push(raw) {
     const b = record(raw, "Gemini response");
     fields2(b, ["candidates", "usageMetadata", "modelVersion", "responseId", "promptFeedback", "error"], "", "unsupported_response");
     if (b.error !== undefined)
-      return this.encoder.push({ error: safeProtocolError() });
+      return this.decorate(this.encoder.push({ error: safeProtocolError() }));
     const events = [];
     if (b.promptFeedback !== undefined) {
       const p = record(b.promptFeedback, "promptFeedback");
@@ -5179,34 +5369,69 @@ class GeminiCanonicalDecoder {
       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) {
+      if (c.content !== undefined && c.content !== null) {
         const content = record(c.content, "content");
         fields2(content, ["role", "parts"], "candidates.content", "unsupported_content");
         if (content.role !== undefined && content.role !== "model")
           fail("unsupported_response", "Response role must be model", "candidates.content.role");
-        const parts = list(content.parts, "parts");
+        const parts = list(content.parts ?? [], "parts");
         if (this.ended && parts.length)
           fail("invalid_stream", "Content arrived after Gemini terminal");
         for (const [i, rawPart] of parts.entries()) {
           const p = record(rawPart, "part");
           fields2(p, ["text", "thought", "functionCall", "thoughtSignature"], "candidates.content.parts", "unsupported_content");
-          if (p.thoughtSignature !== undefined)
+          if (p.thoughtSignature !== undefined && this.context.sourceProtocol !== "responses")
             fail("unsupported_reasoning", "Thought signatures cannot cross protocols", "candidates.content.parts.thoughtSignature");
           if (p.functionCall !== undefined) {
             if (p.text !== undefined || p.thought !== undefined)
               fail("unsupported_content", "Mixed Gemini part kinds", "candidates.content.parts");
             const f = record(p.functionCall, "functionCall");
             fields2(f, ["id", "name", "args"], "functionCall", "unsupported_tool");
-            const index = this.serial++, id = f.id === undefined ? `call_gemini_${index}` : string(f.id, "functionCall.id", true);
-            if (this.ids.has(id))
+            const index = this.serial++, originalId = f.id === undefined ? `call_gemini_${crypto.randomUUID().replaceAll("-", "")}` : string(f.id, "functionCall.id", true);
+            if (this.ids.has(originalId))
               fail("invalid_tool_arguments", "Duplicate Gemini call id", "functionCall.id");
-            this.ids.add(id);
+            this.ids.add(originalId);
+            const id = this.context.sourceProtocol === "responses" ? encodeGeminiCallId(originalId, p.thoughtSignature, limits(this.context.capabilities?.limits).maxArgumentBytes) : originalId;
             this.tools = true;
             events.push(...this.encoder.push({ choices: [{ delta: { tool_calls: [{ index, id, type: "function", function: { name: string(f.name, "functionCall.name", true), arguments: JSON.stringify(record(f.args ?? {}, "functionCall.args")) } }] } }] }));
           } else {
             if (p.thought !== undefined && typeof p.thought !== "boolean")
               fail("invalid_payload", "Thought flag must be boolean", "thought");
-            events.push(...this.encoder.push({ choices: [{ delta: { [p.thought === true ? "reasoning_content" : "content"]: string(p.text, `parts[${i}].text`) } }] }));
+            const text = string(p.text ?? (p.thoughtSignature === undefined ? undefined : ""), `parts[${i}].text`);
+            const output = this.encoder.push({ choices: [{ delta: { [p.thought === true ? "reasoning_content" : "content"]: text } }] });
+            const added = output.find((e) => e.type === "response.output_item.added");
+            if (added)
+              this.contentId = record(added.item, "item").id;
+            const id = this.contentId;
+            let item = this.signed.get(id);
+            if (!item) {
+              item = { id, thought: p.thought === true, parts: [], hasSignature: false, metadataBytes: Buffer.byteLength(JSON.stringify({ id, thought: p.thought === true, parts: [] })) };
+              this.signed.set(id, item);
+            }
+            const signature = p.thoughtSignature === undefined ? undefined : checkedSignature(p.thoughtSignature, limits(this.context.capabilities?.limits).maxArgumentBytes);
+            const previous = item.parts.at(-1);
+            const merge = this.streaming && signature === undefined && previous && previous.signature === undefined && !previous.textAbsent;
+            const partBytes = Buffer.byteLength(JSON.stringify({ length: text.length + (merge ? previous.text.length : 0), hash: "x".repeat(43), ...signature === undefined ? {} : { signature }, ...p.text === undefined ? { textAbsent: true } : {} }));
+            const metadataBytes = item.metadataBytes + partBytes - (merge ? previous.metadataBytes : 0) + (!merge && item.parts.length ? 1 : 0);
+            const hasSignature = item.hasSignature || signature !== undefined;
+            const replayBytes = this.replayBytes + (item.hasSignature ? metadataBytes - item.metadataBytes : hasSignature ? metadataBytes + (this.signedItems ? 1 : 0) : 0);
+            const budget = limits(this.context.capabilities?.limits);
+            if (hasSignature && geminiEnvelopeBytes(replayBytes) > Math.min(budget.maxArgumentBytes, budget.maxOutputBytes))
+              fail("resource_limit", "Accumulated Gemini signatures exceed replay budget");
+            if (hasSignature && !item.hasSignature)
+              this.signedItems++;
+            this.replayBytes = replayBytes;
+            item.metadataBytes = metadataBytes;
+            item.hasSignature = hasSignature;
+            if (merge) {
+              previous.text += text;
+              previous.metadataBytes = partBytes;
+            } else {
+              if (++this.partCount > limits(this.context.capabilities?.limits).maxItems)
+                fail("resource_limit", "Too many Gemini parts");
+              item.parts.push({ text, metadataBytes: partBytes, ...signature === undefined ? {} : { signature }, ...p.text === undefined ? { textAbsent: true } : {} });
+            }
+            events.push(...output);
           }
         }
       }
@@ -5223,25 +5448,47 @@ class GeminiCanonicalDecoder {
     }
     if (b.usageMetadata !== undefined) {
       const u = record(b.usageMetadata, "usageMetadata");
-      fields2(u, ["promptTokenCount", "candidatesTokenCount", "totalTokenCount", "cachedContentTokenCount", "thoughtsTokenCount"], "usageMetadata", "unsupported_response");
-      for (const [k, v] of Object.entries(u))
-        integer(v, `usageMetadata.${k}`);
-      const input = u.promptTokenCount ?? 0, thoughts = u.thoughtsTokenCount ?? 0, output = (u.candidatesTokenCount ?? 0) + thoughts;
+      for (const k of ["promptTokenCount", "candidatesTokenCount", "totalTokenCount", "cachedContentTokenCount", "thoughtsTokenCount", "toolUsePromptTokenCount"])
+        if (u[k] !== undefined && u[k] !== null)
+          integer(u[k], `usageMetadata.${k}`);
+      const input = (u.promptTokenCount ?? 0) + (u.toolUsePromptTokenCount ?? 0), thoughts = u.thoughtsTokenCount ?? 0, output = (u.candidatesTokenCount ?? 0) + thoughts;
       if (u.totalTokenCount !== undefined && u.totalTokenCount !== input + output)
         fail("invalid_usage", "Gemini total does not match reported components", "usageMetadata.totalTokenCount");
       events.push(...this.encoder.push({ choices: [], usage: { prompt_tokens: input, completion_tokens: output, prompt_tokens_details: { cached_tokens: u.cachedContentTokenCount ?? 0 }, completion_tokens_details: { reasoning_tokens: thoughts } } }));
     }
-    return events;
+    return this.decorate(events);
+  }
+  decorate(events) {
+    const output = [];
+    for (const event of events) {
+      if (["response.completed", "response.incomplete", "response.failed"].includes(event.type)) {
+        const signed = [...this.signed.values()].filter((item) => item.parts.some((p) => p.signature !== undefined));
+        if (signed.length) {
+          const budget = limits(this.context.capabilities?.limits), response = record(event.response, "response");
+          const items = list(response.output, "output");
+          if (items.length >= budget.maxItems)
+            fail("resource_limit", "Too many Gemini output items");
+          const item = geminiSignatureItem(signed.map((item) => ({ id: item.id, thought: item.thought, parts: item.parts.map((p) => ({ length: p.text.length, hash: geminiTextHash(p.text), ...p.signature === undefined ? {} : { signature: p.signature }, ...p.textAbsent ? { textAbsent: true } : {} })) })), budget);
+          const body = { ...response, output: [...items, item] };
+          serialized(body, budget.maxOutputBytes, "Gemini response");
+          output.push({ type: "response.output_item.added", response_id: response.id, output_index: items.length, item }, { type: "response.output_item.done", response_id: response.id, output_index: items.length, item });
+          output.push({ ...event, response: body });
+          continue;
+        }
+      }
+      output.push(event);
+    }
+    return output.map((event) => ({ ...event, sequence_number: this.sequence++ }));
   }
   finish() {
-    return this.encoder.finish();
+    return this.decorate(this.encoder.finish());
   }
 }
 function canonicalResponse(raw, context, names) {
   if (context.targetProtocol === "responses")
     return validateCanonicalResponse(raw, context);
   if (context.targetProtocol === "gemini_generate_content") {
-    const decoder = new GeminiCanonicalDecoder(context, names);
+    const decoder = new GeminiCanonicalDecoder(context, names, false);
     const events = [...decoder.push(raw), ...decoder.finish()];
     return record(events.at(-1)?.response, "response");
   }
@@ -5623,7 +5870,7 @@ class CanonicalStreamRenderer {
 var LLM_PROTOCOLS = ["responses", "chat_completions", "anthropic_messages", "gemini_generate_content"];
 
 // packages/llms/src/protocol-session/index.ts
-var PROTOCOL_CONVERSION_RULES_VERSION = "1.0.1";
+var PROTOCOL_CONVERSION_RULES_VERSION = "1.0.4";
 function describeProtocolConversion() {
   return {
     rulesVersion: PROTOCOL_CONVERSION_RULES_VERSION,
@@ -5631,7 +5878,7 @@ function describeProtocolConversion() {
     matrix: LLM_PROTOCOLS.flatMap((sourceProtocol) => LLM_PROTOCOLS.map((targetProtocol) => ({
       sourceProtocol,
       targetProtocol,
-      mode: sourceProtocol === targetProtocol ? "passthrough" : sourceProtocol === "responses" && targetProtocol === "gemini_generate_content" || sourceProtocol === "gemini_generate_content" && targetProtocol === "responses" ? "unsupported" : "convert"
+      mode: sourceProtocol === targetProtocol ? "passthrough" : sourceProtocol === "gemini_generate_content" && targetProtocol === "responses" ? "unsupported" : "convert"
     })))
   };
 }
@@ -5649,9 +5896,9 @@ function createProtocolSession(context) {
     fail("unsupported_protocol", "Unknown protocol");
   if (typeof context.model !== "string" || !context.model)
     fail("invalid_payload", "Target model is required", "model");
-  const unsupported = context.sourceProtocol === "responses" && context.targetProtocol === "gemini_generate_content" || context.sourceProtocol === "gemini_generate_content" && context.targetProtocol === "responses";
+  const unsupported = context.sourceProtocol === "gemini_generate_content" && context.targetProtocol === "responses";
   if (unsupported)
-    fail("unsupported_protocol_pair", "Responses and Gemini direct conversion is not supported");
+    fail("unsupported_protocol_pair", "Gemini to Responses conversion is not supported");
   const same = context.sourceProtocol === context.targetProtocol;
   let disposed = false, poisoned = false, requested = false, mode, finished = false, passTerminal = false, passAnthropicStopped = false;
   let names = new Map;
@@ -5890,7 +6137,7 @@ function protocolRequestModel(protocol, body, url) {
   return model;
 }
 // plugins/llm-protocol-adapter/server/relay.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 
 // plugins/llm-protocol-adapter/server/relay-response.ts
 var RELAY_TOOL = "relay_external_agent_payload";
@@ -6054,7 +6301,7 @@ async function relayPayload(result, param, signal) {
 }
 
 // plugins/llm-protocol-adapter/server/relay.ts
-var hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+var hash = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
 function rejection(param, code, status = 502) {
   return new DataAdmissionError(status, code, undefined, { param, message: "Agent payload relay is unavailable" });
 }
@@ -6260,9 +6507,10 @@ class AgentRelay {
 }
 
 // plugins/llm-protocol-adapter/server/service.ts
-var REASONING_RULES_VERSION = "2026-10-24.1";
+var REASONING_RULES_VERSION = "2026-10-27.1";
 var concrete = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var effortProtocols = new Set(["responses", "chat_completions", "anthropic_messages"]);
+var effortProtocols = new Set(["responses", "chat_completions", "anthropic_messages", "gemini_generate_content"]);
+var geminiEfforts = new Set(["minimal", "low", "medium", "high"]);
 var anthropicEfforts = new Set(["low", "medium", "high", "xhigh", "max"]);
 function identityError(code, message) {
   throw new ResponsesCodecError(code, message, "modelIdentity");
@@ -6287,7 +6535,7 @@ function resolveCapabilities(catalog, context) {
   if (!info)
     return null;
   const restrictions = context.restrictions, reasoningAllowed = info.reasoning && restrictions?.reasoning !== false;
-  const allowed = context.targetProtocol === "anthropic_messages" ? anthropicEfforts : concrete;
+  const allowed = context.targetProtocol === "anthropic_messages" ? anthropicEfforts : context.targetProtocol === "gemini_generate_content" ? geminiEfforts : concrete;
   const candidates = reasoningAllowed && effortProtocols.has(context.targetProtocol) && info.reasoningOptionsStatus === "known" ? info.reasoningOptions?.flatMap((option) => option.type === "effort" ? option.values.filter((value) => typeof value === "string" && allowed.has(value)) : []) ?? [] : [];
   const supportedEfforts = [...new Set(candidates)];
   const wirePolicy = supportedEfforts.length ? { effortMap: Object.fromEntries(supportedEfforts.map((value) => [value, value])) } : null;
@@ -6484,4 +6732,4 @@ export {
   control_default as default
 };
 
-//# debugId=62FD9644C2CB7DAB64756E2164756E21
+//# debugId=165F7F1DADB9687864756E2164756E21