@jeffusion/bungee-core 5.23.0 → 5.23.2

package/dist/plugins/codex-router/manifest.json

@@ -25,25 +25,18 @@
     "llm-protocol-adapter": "^1.0.0"
   },
   "services": {
-    "provides": [],
-    "consumes": [
+    "provides": [
       {
-        "id": "models-dev.catalog.v1",
+        "id": "codex-router.catalog-validators.v1",
         "version": 1,
         "process": "control",
-        "plugin": "models-dev",
-        "kind": "local"
-      },
+        "kind": "rpc"
+      }
+    ],
+    "consumes": [
       {
         "id": "models-dev.catalog.v1",
         "version": 1,
-        "process": "worker",
-        "plugin": "models-dev",
-        "kind": "local"
-      },
-      {
-        "id": "models-dev.capabilities.v1",
-        "version": 1,
         "process": "control",
         "plugin": "models-dev",
         "kind": "local"
@@ -51,7 +44,7 @@
       {
         "id": "models-dev.capabilities.v1",
         "version": 1,
-        "process": "worker",
+        "process": "control",
         "plugin": "models-dev",
         "kind": "local"
       },
@@ -75,6 +68,13 @@
         "process": "worker",
         "plugin": "llm-protocol-adapter",
         "kind": "rpc"
+      },
+      {
+        "id": "codex-router.catalog-validators.v1",
+        "version": 1,
+        "process": "worker",
+        "plugin": "codex-router",
+        "kind": "rpc"
       }
     ]
   },

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

@@ -5849,6 +5849,32 @@ function validateStreamEnvelope(raw, protocol) {
     validateUsage(e.usage, protocol);
   }
 }
+// packages/llms/src/protocol-session/endpoint.ts
+function protocolRequestModel(protocol, body, url) {
+  if (protocol === "gemini_generate_content") {
+    let path;
+    try {
+      path = new URL(url).pathname;
+    } catch {
+      return fail("invalid_payload", "A valid Gemini target URL is required", "url");
+    }
+    const match = path.match(/\/models\/([^/]+):(?:streamGenerateContent|generateContent)$/);
+    if (!match)
+      return fail("invalid_payload", "Gemini target URL has no terminal model", "url");
+    try {
+      const model = decodeURIComponent(match[1]);
+      if (model)
+        return model;
+    } catch {
+      return fail("invalid_payload", "Gemini target model encoding is invalid", "url");
+    }
+    return fail("invalid_payload", "Gemini target model is required", "url");
+  }
+  const model = body?.model;
+  if (typeof model !== "string" || !model)
+    return fail("invalid_payload", "Target model is required", "model");
+  return model;
+}
 // plugins/llm-protocol-adapter/server/relay.ts
 import { createHash } from "crypto";
 
@@ -5886,7 +5912,8 @@ async function relayPayload(result, param, signal) {
     if (result.status < 200 || result.status >= 300)
       throw new DataAdmissionError(result.status === 401 || result.status === 429 ? result.status : 502, "llm_adapter_relay_upstream_failed", undefined, { param, message: `Relay upstream rejected the request (HTTP ${result.status})` });
     let response;
-    if (result.bodyHandle.identity.contentType.includes("text/event-stream") || result.bodyHandle.identity.contentType.includes("application/octet-stream")) {
+    const contentType = result.bodyHandle.identity.contentType;
+    if (contentType === "" || contentType.includes("text/event-stream") || contentType.includes("application/octet-stream")) {
       const iterator = result.bodyHandle.events({ id: "llm-adapter.relay", mandatory: true, signal })[Symbol.asyncIterator]();
       let call, callIndex, args = "", argumentBytes = 0, argumentsDone, outputDone = false, terminal = false, done = false;
       const reasoning = new Map;
@@ -5976,7 +6003,7 @@ async function relayPayload(result, param, signal) {
       } finally {
         await iterator.return?.();
       }
-    } else if (result.bodyHandle.identity.contentType.includes("json"))
+    } else if (contentType.includes("json"))
       response = await result.bodyHandle.json({ id: "llm-adapter.relay", mandatory: true, signal });
     else
       invalid(param);
@@ -6215,10 +6242,25 @@ class AgentRelay {
 }
 
 // plugins/llm-protocol-adapter/server/service.ts
-var REASONING_RULES_VERSION = "2026-10-10.3";
+var REASONING_RULES_VERSION = "2026-10-12.1";
 var concrete = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
-function catalogModel(provider, model) {
-  return provider === "zai" && model === "GLM-5.3-Flash" ? "glm-5.3-flash" : model;
+function identityError(code, message) {
+  throw new ResponsesCodecError(code, message, "modelIdentity");
+}
+function parseModelIdentity(value) {
+  if (value === undefined)
+    return;
+  const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+  const identifier = (v) => typeof v === "string" && v.length > 0 && v === v.trim();
+  if (!object(value) || Object.keys(value).length !== 2 || !Object.keys(value).every((key) => ["wireModel", "catalogModel"].includes(key)) || !identifier(value.wireModel) || !object(value.catalogModel) || Object.keys(value.catalogModel).length !== 2 || !Object.keys(value.catalogModel).every((key) => ["provider", "model"].includes(key)) || !identifier(value.catalogModel.provider) || !identifier(value.catalogModel.model))
+    throw new ResponsesCodecError("invalid_model_identity", "Model identity declaration is invalid", "modelIdentity");
+  return { wireModel: value.wireModel, catalogModel: { provider: value.catalogModel.provider, model: value.catalogModel.model } };
+}
+function checkedIdentity(value, model) {
+  const identity = parseModelIdentity(value);
+  if (identity && identity.wireModel !== model)
+    identityError("model_identity_mismatch", "Declared wire model differs from the actual target");
+  return identity;
 }
 function rule(provider, model, protocol) {
   if (provider === "zai" && ["glm-5.3", "glm-5.3-flash"].includes(model) && protocol === "chat_completions")
@@ -6232,7 +6274,6 @@ function rule(provider, model, protocol) {
   return null;
 }
 function resolveCapabilities(catalog, context) {
-  context = { ...context, model: catalogModel(context.provider, context.model) };
   const info = catalog.model(context);
   if (!info)
     return null;
@@ -6294,8 +6335,15 @@ function conversionService(catalog, worker, history, runBackground) {
     createSession(context) {
       if (!worker)
         throw new Error("llm_adapter_conversion_requires_worker");
-      const info = context.profile ?? catalog.model({ provider: context.provider, model: catalogModel(context.provider, context.model) });
-      const profile = context.profile ? structuredClone(context.profile) : info ? resolveCapabilities(catalog, { provider: info.provider, model: context.model, targetProtocol: context.targetProtocol }) : undefined;
+      const declaration = checkedIdentity(context.modelIdentity, context.model);
+      const restrictions = context.restrictions ? structuredClone(context.restrictions) : undefined;
+      const reference = declaration?.catalogModel ?? { provider: context.provider, model: context.model };
+      const info = context.profile ?? catalog.model(reference);
+      let profile = context.profile ? structuredClone(context.profile) : info ? resolveCapabilities(catalog, { provider: info.provider, model: info.model, targetProtocol: context.targetProtocol, restrictions }) : null;
+      if (declaration && (!profile || profile.provider !== reference.provider || profile.model !== reference.model))
+        identityError("model_identity_unavailable", "Declared catalog model is unavailable");
+      const entryProfile = profile;
+      let catalogVersion = profile?.catalogVersion ?? null;
       let selected = context.selectedEffort;
       const passthrough = context.sourceProtocol === context.targetProtocol;
       if (!passthrough && selected !== undefined && (!profile || !profile.supportedEfforts.includes(selected)))
@@ -6328,29 +6376,56 @@ function conversionService(catalog, worker, history, runBackground) {
             engine.dispose();
           }
         },
-        validateAttempt({ model, protocol, body, url }) {
+        validateAttempt({ model, protocol, body, url, modelIdentity }) {
           if (disposed)
             throw new Error("llm_adapter_session_disposed");
           if (protocol !== context.targetProtocol)
             throw new ResponsesCodecError("target_protocol_mismatch", "Actual target protocol differs from the session", "url");
           if (url) {
-            const path = new URL(url).pathname;
+            let path;
+            try {
+              path = new URL(url).pathname;
+            } catch {
+              throw new ResponsesCodecError("target_protocol_mismatch", "Actual target URL is invalid", "url");
+            }
             const valid = protocol === "responses" ? /\/responses$/.test(path) : protocol === "chat_completions" ? /\/chat\/completions$/.test(path) : protocol === "anthropic_messages" ? /\/messages$/.test(path) : /:(?:streamGenerateContent|generateContent)$/.test(path);
             if (!valid)
               throw new ResponsesCodecError("target_protocol_mismatch", "Actual target URL does not implement the session protocol", "url");
           }
-          const actual = profile && profile.model === catalogModel(profile.provider, model) ? profile : profile ? resolveCapabilities(catalog, { provider: profile.provider, model, targetProtocol: protocol }) : null;
+          const actualModel = protocolRequestModel(protocol, body, url);
+          const identity = checkedIdentity(modelIdentity, actualModel);
+          if (model !== actualModel)
+            identityError("model_identity_mismatch", "Model argument differs from the actual target");
+          model = actualModel;
+          const reference = identity?.catalogModel ?? { provider: profile?.provider ?? context.provider, model };
+          const sameIdentity = !!profile && reference.provider === profile.provider && reference.model === profile.model;
+          const info = sameIdentity ? profile : catalog.model(reference);
+          const actual = sameIdentity ? profile : info ? resolveCapabilities(catalog, { provider: info.provider, model: info.model, targetProtocol: protocol, restrictions }) : null;
+          if (identity && !actual)
+            identityError("model_identity_unavailable", "Declared catalog model is unavailable");
+          if (actual && catalogVersion !== null && actual.catalogVersion !== catalogVersion)
+            identityError("model_identity_catalog_changed", "Target catalog version differs from the generation snapshot");
+          const sameNativeIdentity = entryProfile ? !!actual && actual.provider === entryProfile.provider && actual.model === entryProfile.model : !identity && model === context.model;
           if (selected !== undefined) {
-            if (passthrough && model === context.model && wireEffort(body, protocol) === selected)
-              return { model, effort: selected, catalogVersion: profile?.catalogVersion ?? null, rulesVersion: REASONING_RULES_VERSION };
-            if (!actual || actual.catalogVersion !== profile?.catalogVersion || actual.rulesVersion !== profile?.rulesVersion || !actual.supportedEfforts.includes(selected) || wireEffort(body, protocol) !== selected)
-              fail2("reasoning.effort");
-            if (protocol === "anthropic_messages" && body?.thinking?.type !== "adaptive")
-              fail2("thinking.type");
-            if (protocol === "chat_completions" && profile?.provider === "zai" && body?.thinking?.type !== "enabled")
-              fail2("thinking.type");
+            if (!(passthrough && sameNativeIdentity && wireEffort(body, protocol) === selected)) {
+              if (!entryProfile || !actual || actual.rulesVersion !== entryProfile.rulesVersion || !actual.supportedEfforts.includes(selected) || wireEffort(body, protocol) !== selected)
+                fail2("reasoning.effort");
+              if (protocol === "anthropic_messages" && body?.thinking?.type !== "adaptive")
+                fail2("thinking.type");
+              if (protocol === "chat_completions" && actual.provider === "zai" && body?.thinking?.type !== "enabled")
+                fail2("thinking.type");
+            }
+          } else if (!profile && actual && identity) {
+            profile = structuredClone(actual);
+            catalogVersion = actual.catalogVersion;
           }
-          return { model, effort: selected ?? null, catalogVersion: profile?.catalogVersion ?? null, rulesVersion: REASONING_RULES_VERSION };
+          return {
+            model,
+            catalogModel: actual ? { provider: actual.provider, model: actual.model } : null,
+            effort: selected ?? null,
+            catalogVersion,
+            rulesVersion: REASONING_RULES_VERSION
+          };
         }
       };
       return session;
@@ -6390,4 +6465,4 @@ export {
   control_default as default
 };
 
-//# debugId=6DAF6016267E58B764756E2164756E21
+//# debugId=FD48268D956989F464756E2164756E21