@jeffusion/bungee-core 5.22.0 → 5.23.0

package/dist/plugins/codex-router/index.js

@@ -896,6 +896,29 @@ var manifest_default = {
           }
         ]
       }
+    },
+    {
+      name: "collaborationRelay",
+      type: "object",
+      label: "relay.label",
+      properties: [
+        {
+          name: "target",
+          type: "gateway_target",
+          label: "relay.target",
+          required: true
+        },
+        {
+          name: "model",
+          type: "string",
+          label: "relay.model",
+          required: true,
+          validation: {
+            trimmed: true,
+            max: 512
+          }
+        }
+      ]
     }
   ],
   contributes: {
@@ -919,26 +942,27 @@ var manifest_default = {
       "metadata.name": "Codex \u6A21\u578B\u8DEF\u7531",
       "plugin.description": "\u4ECE\u5171\u4EAB\u76EE\u5F55\u9009\u62E9\u6A21\u578B\u5E76\u7ED1\u5B9A\u5DF2\u6709\u8DEF\u7531\u6216\u670D\u52A1",
       "models.label": "\u6A21\u578B\u7ED1\u5B9A",
-      "editor.description": "\u6309\u539F\u59CB\u6A21\u578B\u5339\u914D\u8BF7\u6C42\uFF0C\u5C06\u76EE\u6807\u6A21\u578B\u8F6C\u53D1\u5230\u6307\u5B9A\u8DEF\u7531\u6216\u670D\u52A1\u3002",
       "editor.binding": "\u7ED1\u5B9A",
       "editor.match": "\u5339\u914D\u8BF7\u6C42",
       "editor.sourceProvider": "\u539F\u59CB\u63D0\u4F9B\u5546",
       "editor.manual": "\u624B\u52A8\u8F93\u5165",
       "editor.fromCatalog": "\u4ECE\u76EE\u5F55\u9009\u62E9",
       "editor.source": "\u539F\u59CB\u6A21\u578B",
-      "editor.sourceHint": "\u7CBE\u786E\u5339\u914D\u5BA2\u6237\u7AEF\u8BF7\u6C42\u4E2D\u7684\u6A21\u578B\u6807\u8BC6\uFF1B\u4F9B\u5E94\u5546\u4EC5\u7528\u4E8E\u76EE\u5F55\u7B5B\u9009\u3002",
       "editor.sourcePlaceholder": "\u4F8B\u5982 gpt-5.4",
       "editor.provider": "\u76EE\u6807\u63D0\u4F9B\u5546",
       "editor.model": "\u76EE\u6807\u6A21\u578B",
-      "editor.target": "\u8F6C\u53D1\u8DEF\u7531 / \u670D\u52A1",
-      "editor.targetPlaceholder": "\u9009\u62E9\u5DF2\u6709\u8DEF\u7531\u6216\u670D\u52A1",
+      "editor.target": "\u8F6C\u53D1\u76EE\u6807",
+      "editor.targetType": "\u76EE\u6807\u7C7B\u578B",
+      "editor.targetTypePlaceholder": "\u9009\u62E9\u76EE\u6807\u7C7B\u578B",
+      "editor.routePlaceholder": "\u9009\u62E9\u8DEF\u7531",
+      "editor.servicePlaceholder": "\u9009\u62E9\u670D\u52A1",
+      "editor.forward": "\u8F6C\u53D1\u8BF7\u6C42",
       "editor.search": "\u641C\u7D22\u6A21\u578B",
       "editor.empty": "\u6CA1\u6709\u5339\u914D\u7684\u6A21\u578B",
       "editor.loading": "\u6B63\u5728\u52A0\u8F7D\u6A21\u578B\u76EE\u5F55",
       "editor.error": "\u76EE\u5F55\u4E0D\u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5 models.dev \u6216\u91CD\u8BD5\u3002",
       "editor.targetsError": "\u65E0\u6CD5\u8BFB\u53D6\u8F6C\u53D1\u76EE\u6807\uFF0C\u8BF7\u91CD\u8BD5\u3002",
       "editor.retry": "\u91CD\u8BD5",
-      "editor.add": "\u6DFB\u52A0\u6A21\u578B\u7ED1\u5B9A",
       "editor.remove": "\u79FB\u9664",
       "editor.noBindings": "\u5C1A\u672A\u914D\u7F6E\u6A21\u578B\u7ED1\u5B9A\u3002",
       "editor.noCatalog": "\u76EE\u5F55\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u542F\u7528 models.dev \u5E76\u5237\u65B0\u76EE\u5F55\u3002",
@@ -957,7 +981,20 @@ var manifest_default = {
       "editor.route": "\u8DEF\u7531",
       "editor.service": "\u670D\u52A1",
       "editor.targetUnavailable": "\u76EE\u6807\u4E0D\u53EF\u7528",
-      "editor.noOptions": "\u6CA1\u6709\u5339\u914D\u7684\u9009\u9879"
+      "editor.noOptions": "\u6CA1\u6709\u5339\u914D\u7684\u9009\u9879",
+      "relay.label": "\u534F\u4F5C\u4E2D\u7EE7",
+      "relay.target": "\u4E2D\u7EE7\u76EE\u6807",
+      "relay.model": "\u4E2D\u7EE7\u6A21\u578B",
+      "relay.modelPlaceholder": "\u9009\u62E9 OpenAI \u6A21\u578B",
+      "relay.modelInvalid": "\u8BF7\u9009\u62E9\u6709\u6548\u7684\u4E2D\u7EE7\u6A21\u578B\u3002",
+      "relay.targetRequired": "\u8BF7\u9009\u62E9\u53EF\u7528\u7684\u4E2D\u7EE7\u8DEF\u7531\u6216\u670D\u52A1\u3002",
+      "relay.protocolInvalid": "\u4E2D\u7EE7\u76EE\u6807\u63A5\u6536\u534F\u8BAE\u5FC5\u987B\u4E3A Responses\u3002",
+      "editor.mode": "\u7ED1\u5B9A\u65B9\u5F0F",
+      "editor.addModel": "\u65B0\u589E\u6A21\u578B",
+      "editor.replaceModel": "\u66FF\u6362\u6A21\u578B",
+      "editor.addReplacement": "\u6DFB\u52A0\u6A21\u578B\u66FF\u6362",
+      "editor.bindingInvalid": "\u8BF7\u586B\u5199\u6709\u6548\u7684\u6A21\u578B\u3001\u8F6C\u53D1\u76EE\u6807\u548C\u534F\u8BAE\u3002",
+      "editor.modelConflict": "\u6A21\u578B\u7ED1\u5B9A\u91CD\u590D\uFF0C\u8BF7\u4FEE\u6539\u6A21\u578B\u6216\u79FB\u9664\u91CD\u590D\u7ED1\u5B9A\u3002"
     },
     en: {
       "editor.loaded": "Loaded",
@@ -966,26 +1003,27 @@ var manifest_default = {
       "metadata.name": "Codex Router",
       "plugin.description": "Bind catalog models to existing routes or services",
       "models.label": "Model bindings",
-      "editor.description": "Match the original model and forward the target model through an existing route or service.",
       "editor.binding": "Binding",
       "editor.match": "Match request",
       "editor.sourceProvider": "Original provider",
       "editor.manual": "Enter manually",
       "editor.fromCatalog": "Choose from catalog",
       "editor.source": "Original model",
-      "editor.sourceHint": "Match the exact model ID in client requests; the provider only filters the catalog.",
       "editor.sourcePlaceholder": "For example, gpt-5.4",
       "editor.provider": "Target provider",
       "editor.model": "Target model",
-      "editor.target": "Forwarding route / service",
-      "editor.targetPlaceholder": "Select an existing route or service",
+      "editor.target": "Forwarding target",
+      "editor.targetType": "Target type",
+      "editor.targetTypePlaceholder": "Select a target type",
+      "editor.routePlaceholder": "Select a route",
+      "editor.servicePlaceholder": "Select a service",
+      "editor.forward": "Forward request",
       "editor.search": "Search models",
       "editor.empty": "No matching models",
       "editor.loading": "Loading model catalog",
       "editor.error": "Catalog unavailable. Check models.dev or retry.",
       "editor.targetsError": "Unable to load forwarding targets. Please retry.",
       "editor.retry": "Retry",
-      "editor.add": "Add model binding",
       "editor.remove": "Remove",
       "editor.noBindings": "No model bindings configured.",
       "editor.noCatalog": "The catalog is empty. Enable models.dev and refresh it first.",
@@ -1004,13 +1042,36 @@ var manifest_default = {
       "editor.route": "Route",
       "editor.service": "Service",
       "editor.targetUnavailable": "Target unavailable",
-      "editor.noOptions": "No matching options"
+      "editor.noOptions": "No matching options",
+      "relay.label": "Collaboration relay",
+      "relay.target": "Relay target",
+      "relay.model": "Relay model",
+      "relay.modelPlaceholder": "Select an OpenAI model",
+      "relay.modelInvalid": "Select a valid relay model.",
+      "relay.targetRequired": "Select an available relay route or service.",
+      "relay.protocolInvalid": "The relay target must receive Responses.",
+      "editor.mode": "Binding mode",
+      "editor.addModel": "Add model",
+      "editor.replaceModel": "Replace model",
+      "editor.addReplacement": "Add model replacement",
+      "editor.bindingInvalid": "Select valid models, a forwarding target and a protocol.",
+      "editor.modelConflict": "Duplicate model binding. Change the model or remove the duplicate."
     }
   },
   uiExtensionMode: "none"
 };
 
 // plugins/codex-router/server/config.ts
+function parseCollaborationRelay(value) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("codex_router_invalid_collaboration_relay");
+  const relay = value, target = relay.target;
+  if (Object.keys(relay).some((key) => !["target", "model"].includes(key)) || typeof relay.model !== "string" || !relay.model || relay.model !== relay.model.trim() || relay.model.length > 512 || /[\x00-\x1f\x7f]/.test(relay.model) || !target || typeof target !== "object" || Array.isArray(target) || !["route", "service"].includes(target.type) || typeof target.id !== "string" || !target.id || target.id !== target.id.trim() || target.id.length > 512 || /[\x00-\x1f\x7f]/.test(target.id) || target.protocol !== "responses" || Object.keys(target).some((key) => !["type", "id", "protocol"].includes(key)))
+    throw new Error("codex_router_invalid_collaboration_relay");
+  return Object.freeze(structuredClone(relay));
+}
 function bindingSource(binding) {
   return binding.source ?? binding.alias ?? binding.model;
 }
@@ -1167,11 +1228,13 @@ var CodexRouterPlugin = definePlugin(class {
   static version = "1.0.0";
   static configSchema = manifest_default.configSchema;
   bindings;
+  relay;
   history;
   catalog;
   conversion;
   constructor(options) {
     this.bindings = parseBindings(options?.models);
+    this.relay = parseCollaborationRelay(options?.collaborationRelay);
   }
   async init(context) {
     if (context.scope?.type !== "route")
@@ -1185,7 +1248,7 @@ var CodexRouterPlugin = definePlugin(class {
   }
   register(hooks) {
     hooks.onWebSocketSessionMode.tap("codex-router.session", (url) => /\/responses$/.test(url.pathname) ? "responses" : undefined);
-    hooks.onDispatchRequest.tapPromise("codex-router.binding", async ({ context, targets, principal, servingRevision, signal }) => {
+    hooks.onDispatchRequest.tapPromise("codex-router.binding", async ({ context, targets }) => {
       if (context.method !== "POST" || !/\/responses$/.test(context.originalUrl.pathname))
         return;
       const binding = this.bindings.find((binding) => bindingSource(binding) === context.body?.model);
@@ -1197,75 +1260,106 @@ var CodexRouterPlugin = definePlugin(class {
       const capabilities = this.conversion.resolveCapabilities({ provider: binding.provider, model: binding.model, targetProtocol: protocol, restrictions: binding.capabilityOverrides });
       if (!capabilities || capabilities.contextWindow === null || !capabilities.inputModalities.includes("text"))
         throw new DataAdmissionError(503, "codex_router_model_unavailable");
-      const scope = principal?.domain !== "anonymous" && principal?.keyId ? createHash2("sha256").update(JSON.stringify([principal, context.routeId, servingRevision ?? null, this.bindings])).digest("hex") : null;
-      const input = structuredClone(context.body);
-      let requiredUpstreamId;
-      let opaqueRestored = false;
-      if (input.previous_response_id) {
-        if (!scope)
-          throw new DataAdmissionError(422, "codex_router_history_identity_required");
-        const prior = await this.history.get({ scope, id: input.previous_response_id }, { signal });
-        if (!prior)
-          throw new DataAdmissionError(422, "codex_router_history_missing_start_new_conversation");
-        const delta = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
-        if (!Array.isArray(delta))
+      context.body = { ...context.body, model: binding.model };
+      return { target: binding.target, protocol, prepareRequest: async ({ context, principal, servingRevision, signal, executeAuxiliary, webSocketConnection }) => {
+        const entryScope = createHash2("sha256").update(JSON.stringify([context.routeId, servingRevision ?? null, this.bindings, this.relay])).digest("hex");
+        const scope = principal?.domain !== "anonymous" && principal?.keyId ? createHash2("sha256").update(JSON.stringify([principal, entryScope])).digest("hex") : null;
+        let input = structuredClone(context.body);
+        let requiredUpstreamId;
+        let opaqueRestored = false;
+        if (input.previous_response_id) {
+          if (!scope)
+            throw new DataAdmissionError(422, "codex_router_history_identity_required");
+          const prior = await this.history.get({ scope, id: input.previous_response_id }, { signal });
+          if (!prior)
+            throw new DataAdmissionError(422, "codex_router_history_missing_start_new_conversation");
+          const delta = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
+          if (!Array.isArray(delta))
+            throw new DataAdmissionError(422, "codex_router_invalid_history");
+          if (prior.items.some((item) => item.encrypted_content || item.type === "compaction")) {
+            if (protocol !== "responses" || JSON.stringify(prior.target) !== JSON.stringify(binding.target) || prior.origin?.provider !== binding.provider || prior.origin?.model !== binding.model || !prior.origin?.upstreamId)
+              throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
+            requiredUpstreamId = prior.origin.upstreamId;
+            opaqueRestored = true;
+          }
+          input.input = [...prior.items, ...delta];
+          delete input.previous_response_id;
+        }
+        if (input.conversation || input.response_id)
+          throw new DataAdmissionError(422, "codex_router_unsupported_history_reference");
+        input.model = binding.model;
+        let logicalInput = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
+        if (!Array.isArray(logicalInput))
           throw new DataAdmissionError(422, "codex_router_invalid_history");
-        if (prior.items.some((item) => item.encrypted_content || item.type === "compaction")) {
-          if (protocol !== "responses" || JSON.stringify(prior.target) !== JSON.stringify(binding.target) || prior.origin?.provider !== binding.provider || prior.origin?.model !== binding.model || !prior.origin?.upstreamId)
-            throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
-          requiredUpstreamId = prior.origin.upstreamId;
-          opaqueRestored = true;
+        if (protocol !== "responses" && !opaqueRestored && logicalInput.some((item) => item?.encrypted_content || item?.type === "compaction"))
+          throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
+        const hasTools = input.tools?.length || logicalInput.some((item) => item?.type === "additional_tools" && item.tools?.length);
+        if (hasTools && (!capabilities.toolCall || binding.capabilityOverrides?.tools === false))
+          throw new DataAdmissionError(422, "codex_router_tools_unsupported");
+        let relayDiagnostics = [];
+        if (protocol !== "responses") {
+          try {
+            const inspected = this.conversion.inspectAgentMessages(input);
+            for (const message of inspected.messages)
+              if (message.encryptedContents.length > 1)
+                throw new DataAdmissionError(422, "llm_adapter_agent_message_multiple_encrypted_blocks", undefined, { param: message.encryptedContents[1].param, message: "Multiple encrypted agent blocks cannot be restored losslessly" });
+            const replacements = [];
+            for (const message of inspected.messages)
+              for (const encrypted of message.encryptedContents) {
+                if (!this.relay)
+                  throw new DataAdmissionError(422, "llm_adapter_agent_message_relay_required", undefined, { param: encrypted.param, message: "Encrypted agent content requires a configured relay" });
+                const text = await this.conversion.relayAgentMessage({ message: input.input[message.inputIndex], contentIndex: encrypted.contentIndex, param: encrypted.param, relay: this.relay, entryScope, scope, requestId: context.requestId, signal, executeAuxiliary, webSocketConnection });
+                replacements.push({ param: encrypted.param, text });
+              }
+            if (replacements.length) {
+              const replaced = this.conversion.replaceAgentMessageEncryptedContent(input, replacements);
+              input = replaced.body;
+              relayDiagnostics = replaced.diagnostics;
+            }
+          } catch (error) {
+            const e = error;
+            if (typeof e.code === "string" && e.name !== "DataAdmissionError")
+              throw new DataAdmissionError(422, `llm_adapter_${e.code}`, undefined, { message: "Agent message cannot be converted", param: e.param });
+            throw error;
+          }
         }
-        input.input = [...prior.items, ...delta];
-        delete input.previous_response_id;
-      }
-      if (input.conversation || input.response_id)
-        throw new DataAdmissionError(422, "codex_router_unsupported_history_reference");
-      input.model = binding.model;
-      let logicalInput = typeof input.input === "string" ? [{ role: "user", content: input.input }] : input.input;
-      if (!Array.isArray(logicalInput))
-        throw new DataAdmissionError(422, "codex_router_invalid_history");
-      if (!opaqueRestored && logicalInput.some((item) => item?.encrypted_content || item?.type === "compaction"))
-        throw new DataAdmissionError(422, "codex_router_unrestorable_history_start_new_conversation");
-      const hasTools = input.tools?.length || logicalInput.some((item) => item?.type === "additional_tools" && item.tools?.length);
-      if (hasTools && (!capabilities.toolCall || binding.capabilityOverrides?.tools === false))
-        throw new DataAdmissionError(422, "codex_router_tools_unsupported");
-      let diagnostics;
-      let session;
-      try {
-        session = this.conversion.createSession({ sourceProtocol: "responses", targetProtocol: protocol, model: binding.model, responseModel: bindingSource(binding), provider: binding.provider, profile: capabilities, selectedEffort: input.reasoning?.effort });
-      } catch (error) {
-        const e = error;
-        if (typeof e.code === "string")
-          throw new DataAdmissionError(422, `llm_adapter_${e.code}`, undefined, { message: e.message, param: e.param });
-        throw error;
-      }
-      try {
-        const decoded = session.convertRequest(input);
-        context.body = structuredClone(decoded.body);
-        if (protocol !== "responses")
-          logicalInput = structuredClone(decoded.canonicalHistory);
-        diagnostics = structuredClone(decoded.diagnostics);
-      } catch (error) {
-        session.dispose();
-        const e = error;
-        if (typeof e.code === "string")
-          throw new DataAdmissionError(422, `llm_adapter_${e.code}`, undefined, { message: e.message, param: e.param });
-        throw error;
-      }
-      if (protocol !== "responses")
-        context.url.pathname = context.url.pathname.replace(/\/responses$/, protocol === "chat_completions" ? "/chat/completions" : "/messages");
-      const adapter = protocolAdapter({
-        session,
-        protocol,
-        model: bindingSource(binding),
-        signal,
-        save: async (response, responseContext) => {
-          if (scope && typeof response.id === "string")
-            await this.history.put({ scope, id: response.id, value: { target: binding.target, origin: { provider: binding.provider, model: binding.model, upstreamId: responseContext?.upstreamId }, items: [...logicalInput, ...response.output] } }, { signal, operationId: crypto.randomUUID() });
+        let diagnostics;
+        let session;
+        try {
+          session = this.conversion.createSession({ sourceProtocol: "responses", targetProtocol: protocol, model: binding.model, responseModel: bindingSource(binding), provider: binding.provider, profile: capabilities, selectedEffort: input.reasoning?.effort, ...protocol !== "responses" ? { agentMessageDelivery: "plaintext" } : {} });
+        } catch (error) {
+          const e = error;
+          if (typeof e.code === "string")
+            throw new DataAdmissionError(422, `llm_adapter_${e.code}`, undefined, { message: e.message, param: e.param });
+          throw error;
+        }
+        try {
+          const decoded = session.convertRequest(input);
+          context.body = structuredClone(decoded.body);
+          if (protocol !== "responses")
+            logicalInput = structuredClone(decoded.canonicalHistory);
+          diagnostics = structuredClone([...relayDiagnostics, ...decoded.diagnostics]);
+        } catch (error) {
+          session.dispose();
+          const e = error;
+          if (typeof e.code === "string")
+            throw new DataAdmissionError(422, `llm_adapter_${e.code}`, undefined, { message: e.message, param: e.param });
+          throw error;
         }
-      });
-      return { target: binding.target, protocol, requiredUpstreamId, adapter, ...protocol !== "responses" ? { canonicalInput: logicalInput, diagnostics } : {} };
+        if (protocol !== "responses")
+          context.url.pathname = context.url.pathname.replace(/\/responses$/, protocol === "chat_completions" ? "/chat/completions" : "/messages");
+        const adapter = protocolAdapter({
+          session,
+          protocol,
+          model: bindingSource(binding),
+          signal,
+          save: async (response, responseContext) => {
+            if (scope && typeof response.id === "string")
+              await this.history.put({ scope, id: response.id, value: { target: binding.target, origin: { provider: binding.provider, model: binding.model, upstreamId: responseContext?.upstreamId }, items: [...logicalInput, ...response.output] } }, { signal, operationId: crypto.randomUUID() });
+          }
+        });
+        return { requiredUpstreamId, adapter, ...protocol !== "responses" ? { canonicalInput: logicalInput, diagnostics } : {} };
+      } };
     });
     hooks.onBeforeRequest.tap("codex-router.catalog-validator", (context) => {
       if (context.method === "GET" && /\/models$/.test(context.originalUrl.pathname)) {
@@ -1296,4 +1390,4 @@ export {
   server_default as default
 };
 
-//# debugId=B0DF8A3FDB79AE4D64756E2164756E21
+//# debugId=15F3624284EDF84064756E2164756E21