@jeffusion/bungee-core 5.23.0 → 5.23.2

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

@@ -851,6 +851,7 @@ var retryActionBrand = Symbol.for("@jeffusion/bungee/request-retry-action");
 var HOUR = 3600000;
 var TOKEN_STATS_RETENTION_MS = 31 * 24 * HOUR;
 // plugins/models-dev/contract.ts
+var MODEL_IDENTITY_ANNOTATION_KEY = "models-dev.model-identity";
 var MODELS_DEV_CATALOG_SNAPSHOT_ID = "models-dev.catalog.snapshot.v1";
 var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION = 1;
 var MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA = Object.freeze({
@@ -909,6 +910,9 @@ function historyClient(rpc) {
     }
   };
 }
+function readModelIdentity(annotations) {
+  return annotations?.[MODEL_IDENTITY_ANNOTATION_KEY];
+}
 // node_modules/base64-js/index.js
 var $toByteArray = toByteArray;
 var lookup = [];
@@ -6031,6 +6035,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";
 
@@ -6151,7 +6181,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;
@@ -6241,7 +6272,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);
@@ -6480,10 +6511,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")
@@ -6497,7 +6543,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;
@@ -6559,8 +6604,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)))
@@ -6593,29 +6645,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;
@@ -6650,7 +6729,7 @@ function responseHandler(input) {
     hooks.onValidateOutbound.tapPromise("llm-adapter.target", async (outbound) => {
       check();
       try {
-        const result = input.session.validateAttempt({ model: outbound.model ?? input.model, protocol: input.targetProtocol, body: outbound.body, url: outbound.url });
+        const result = input.session.validateAttempt({ model: protocolRequestModel(input.targetProtocol, outbound.body, outbound.url), modelIdentity: readModelIdentity(outbound.annotations), protocol: input.targetProtocol, body: outbound.body, url: outbound.url });
         logger.info({ requestId: outbound.requestId, attemptId: outbound.attemptId, ...result }, "llm_adapter_target_validated");
         input.log?.(result);
       } catch (e) {
@@ -6658,6 +6737,8 @@ function responseHandler(input) {
       }
       return outbound;
     });
+    if (input.validationOnly)
+      return;
     hooks.onResponse.tapPromise("llm-adapter.response", async (response, ctx) => {
       context = ctx;
       if (!response.ok || !response.headers.get("content-type")?.includes("json"))
@@ -6984,7 +7065,7 @@ var server_default = definePlugin(class {
     });
   }
   bodyRequirements(ctx) {
-    return this.applied && ctx.method === "POST" && protocolForPath(ctx.url.pathname) !== null ? { request: "json-write", response: ["json", "sse-json"] } : { request: "none" };
+    return this.applied && ctx.method === "POST" && protocolForPath(ctx.url.pathname) !== null ? { request: "json-write", ...this.options?.sourceProtocol !== this.options?.targetProtocol ? { response: ["json", "sse-json"] } : {} } : { request: "none" };
   }
   register(hooks) {
     if (!this.applied)
@@ -7000,27 +7081,42 @@ var server_default = definePlugin(class {
       }
       if (source !== this.options.sourceProtocol)
         throw new DataAdmissionError(422, "llm_adapter_source_protocol_mismatch");
-      if (source === this.options.targetProtocol)
-        return ctx;
-      if (this.active.has(ctx.requestId))
+      if (this.active.has(ctx.requestId)) {
+        if (source === this.options.targetProtocol)
+          return ctx;
         throw new DataAdmissionError(422, "llm_adapter_duplicate_conversion");
-      const model = source === "gemini_generate_content" ? decodeURIComponent(ctx.url.pathname.match(/\/models\/([^/]+):/)[1]) : ctx.body?.model;
-      if (typeof model !== "string" || !model)
-        throw new DataAdmissionError(422, "llm_adapter_model_required");
-      const session = this.service.createSession({ sourceProtocol: source, targetProtocol: this.options.targetProtocol, model, ...source === "gemini_generate_content" ? { streaming: ctx.url.pathname.endsWith(":streamGenerateContent") } : {} });
+      }
+      let session;
+      let model;
       try {
+        model = protocolRequestModel(source, ctx.body, ctx.url);
+        session = this.service.createSession({
+          sourceProtocol: source,
+          targetProtocol: this.options.targetProtocol,
+          model,
+          modelIdentity: readModelIdentity(ctx.annotations),
+          ...source === "gemini_generate_content" ? { streaming: ctx.url.pathname.endsWith(":streamGenerateContent") } : {}
+        });
         const result = session.convertRequest(ctx.body);
-        if (result.diagnostics.length)
-          logger.info({ requestId: ctx.requestId, diagnostics: structuredClone(result.diagnostics) }, "llm_adapter_request_diagnostics");
-        ctx.body = structuredClone(result.body);
-        ctx.url.pathname = targetPath(ctx.url.pathname, this.options.targetProtocol, model, result.streaming);
-        if (this.options.targetProtocol === "gemini_generate_content" && result.streaming)
-          ctx.url.searchParams.set("alt", "sse");
+        if (source !== this.options.targetProtocol) {
+          if (result.diagnostics.length)
+            logger.info({ requestId: ctx.requestId, diagnostics: structuredClone(result.diagnostics) }, "llm_adapter_request_diagnostics");
+          ctx.body = structuredClone(result.body);
+          ctx.url.pathname = targetPath(ctx.url.pathname, this.options.targetProtocol, model, result.streaming);
+          if (this.options.targetProtocol === "gemini_generate_content" && result.streaming)
+            ctx.url.searchParams.set("alt", "sse");
+        }
       } catch (error) {
-        session.dispose();
+        session?.dispose();
         adapterError(error);
       }
-      const handler = responseHandler({ session, sourceProtocol: source, targetProtocol: this.options.targetProtocol, model });
+      const handler = responseHandler({
+        session,
+        sourceProtocol: source,
+        targetProtocol: this.options.targetProtocol,
+        model,
+        validationOnly: source === this.options.targetProtocol
+      });
       this.active.set(ctx.requestId, { handler, session });
       return ctx;
     });
@@ -7047,4 +7143,4 @@ export {
   targetPath
 };
 
-//# debugId=04C6BEB6A1F100D964756E2164756E21
+//# debugId=40CBB2F3F4855EA864756E2164756E21