@sema-agent/core 7.23.4 → 7.24.0

package/dist/brain/errors.js

@@ -1,4 +1,4 @@
-import { thrownText } from "../core/thrown-value.js";
+import { isErrorLike, readMember, thrownText } from "../core/thrown-value.js";
 export const ZERO_USAGE = {
     input: 0,
     output: 0,
@@ -82,16 +82,12 @@ const STALE_CONNECTION_CODES = new Set([
     "StreamSuspended",
 ]);
 function hasStaleConnectionCode(e) {
-    try {
-        let cur = e;
-        for (let depth = 0; depth < 5 && cur !== undefined && cur !== null; depth++) {
-            const code = typeof cur.code === "string" ? cur.code : undefined;
-            if (code !== undefined && STALE_CONNECTION_CODES.has(code))
-                return true;
-            cur = cur instanceof Error ? cur.cause : undefined;
-        }
-    }
-    catch {
+    let cur = e;
+    for (let depth = 0; depth < 5 && cur !== undefined && cur !== null; depth++) {
+        const code = readMember(cur, "code");
+        if (typeof code === "string" && STALE_CONNECTION_CODES.has(code))
+            return true;
+        cur = isErrorLike(cur) ? readMember(cur, "cause") : undefined;
     }
     return false;
 }
@@ -104,25 +100,26 @@ function walkConnectFailure(node, budget) {
     if (node === undefined || node === null)
         return "silent";
     let verdict = "silent";
-    const code = node.code;
+    const code = readMember(node, "code");
     if (typeof code === "string") {
         if (!DETERMINISTIC_CONNECT_CODES.has(code))
             return "indeterminate";
         verdict = "deterministic";
     }
-    if (!(node instanceof Error))
+    if (!isErrorLike(node))
         return verdict;
-    const members = node.errors;
-    if (Array.isArray(members)) {
-        if (members.length === 0)
+    const members = readMember(node, "errors");
+    const legCount = readMember(members, "length");
+    if (members !== undefined) {
+        if (typeof legCount !== "number" || !Number.isInteger(legCount) || legCount <= 0)
             return "indeterminate";
-        for (const member of members) {
-            if (walkConnectFailure(member, budget) !== "deterministic")
+        for (let i = 0; i < legCount; i++) {
+            if (walkConnectFailure(readMember(members, String(i)), budget) !== "deterministic")
                 return "indeterminate";
         }
         verdict = "deterministic";
     }
-    const cause = node.cause;
+    const cause = readMember(node, "cause");
     if (cause !== undefined && cause !== null) {
         const below = walkConnectFailure(cause, budget);
         if (below === "indeterminate")
@@ -135,21 +132,42 @@ function walkConnectFailure(node, budget) {
 export function classifyConnectFailure(e) {
     return walkConnectFailure(e, { left: CONNECT_GRAPH_NODE_BUDGET }) === "deterministic" ? "deterministic" : "indeterminate";
 }
+const FETCH_TRANSPORT_SHELLS = new Set(["fetch failed", "terminated"]);
+const REQUEST_ARGUMENT_CODES = new Set(["ERR_INVALID_URL"]);
+export function classifyFetchThrow(e) {
+    if (readMember(e, "name") !== "TypeError")
+        return "transport";
+    const message = readMember(e, "message");
+    if (typeof message === "string" && FETCH_TRANSPORT_SHELLS.has(message))
+        return "transport";
+    const cause = readMember(e, "cause");
+    if (cause === undefined || cause === null)
+        return "request_unbuildable";
+    const code = readMember(cause, "code");
+    return typeof code === "string" && REQUEST_ARGUMENT_CODES.has(code) ? "request_unbuildable" : "transport";
+}
+export function abortLikeName(err) {
+    if (!isErrorLike(err))
+        return undefined;
+    const name = readMember(err, "name");
+    return name === "AbortError" || name === "TimeoutError" ? name : undefined;
+}
+export function brainErrorCodeOf(e) {
+    const code = readMember(e, "code");
+    return typeof code === "string" && BRAIN_ERROR_CODES.includes(code) ? code : undefined;
+}
 export function describeNetworkError(e) {
     const top = thrownText(e);
     const parts = [];
-    try {
-        let cur = e instanceof Error ? e.cause : undefined;
-        for (let depth = 0; depth < 4 && cur !== undefined && cur !== null; depth++) {
-            const code = typeof cur.code === "string" ? cur.code : undefined;
-            const msg = thrownText(cur);
-            const piece = code !== undefined && !msg.includes(code) ? `${code}: ${msg}` : msg;
-            if (piece.length > 0 && piece !== top && !parts.includes(piece))
-                parts.push(piece);
-            cur = cur instanceof Error ? cur.cause : undefined;
-        }
-    }
-    catch {
+    let cur = isErrorLike(e) ? readMember(e, "cause") : undefined;
+    for (let depth = 0; depth < 4 && cur !== undefined && cur !== null; depth++) {
+        const rawCode = readMember(cur, "code");
+        const code = typeof rawCode === "string" ? rawCode : undefined;
+        const msg = thrownText(cur);
+        const piece = code !== undefined && !msg.includes(code) ? `${code}: ${msg}` : msg;
+        if (piece.length > 0 && piece !== top && !parts.includes(piece))
+            parts.push(piece);
+        cur = isErrorLike(cur) ? readMember(cur, "cause") : undefined;
     }
     const body = parts.length > 0 ? `${top} (${parts.join(" ← ")})` : top;
     return hasStaleConnectionCode(e) ? `${body} — possibly a stale connection; a fresh one may succeed` : body;

package/dist/brain/failover.js

@@ -1,5 +1,5 @@
 import { createAssistantMessageEventStream, } from "../internal/llm.js";
-import { extractErrorCode } from "./errors.js";
+import { abortLikeName, extractErrorCode } from "./errors.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { passthroughStream } from "./degrading.js";
 import { thrownText } from "../core/thrown-value.js";
@@ -65,8 +65,7 @@ export function createFailoverBrain(brains) {
                 }
             }
             catch (e) {
-                const aborted = options?.signal?.aborted === true ||
-                    (e instanceof Error && (e.name === "AbortError" || e.name === "TimeoutError"));
+                const aborted = options?.signal?.aborted === true || abortLikeName(e) !== undefined;
                 const errorMsg = {
                     role: "assistant",
                     content: [{ type: "text", text: "" }],

package/dist/brain/open-responses.js

@@ -6,7 +6,7 @@ import { mintFallbackToolCallId } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
 import { OUTPUT_CAP_KEYS, RESPONSES_RESERVED, applyExtraBody, effectiveOutputCap, lockHeader, mergeHeaders } from "./request-params.js";
-import { adjudicateModelRoute, applyRouteCredentialHeaders, createBrainRouteJudge, resolveRouteCredential, routeRefusalText } from "./route-adjudicator.js";
+import { adjudicateModelRoute, applyRouteCredentialHeaders, assertServableRequestRoot, createBrainRouteJudge, resolveRequestRoot, resolveRouteCredential, routeRefusalText } from "./route-adjudicator.js";
 import { declaredOffSpelling, mintEffortWireValue, reasoningRequestCarried } from "./reasoning.js";
 import { runStreamingBrain } from "./stream-engine.js";
 const DEGENERATE_POLL_CHARS = 64;
@@ -217,6 +217,7 @@ function mapTerminalStopReason(incompleteReason, hadToolCalls) {
     return "stop";
 }
 export function createOpenResponsesBrain(config = {}) {
+    assertServableRequestRoot(config.baseUrl, "config.baseUrl");
     const doFetch = config.fetchImpl ?? fetch;
     const stream = (model, context, options) => {
         let sentMaxTokens;
@@ -232,6 +233,10 @@ export function createOpenResponsesBrain(config = {}) {
             httpLabel: "responses",
             stallTimeouts: options?.stallTimeouts,
             buildRequest: (overrides) => {
+                const root = resolveRequestRoot(model.baseUrl, config.baseUrl);
+                if (!root) {
+                    throw new Error("createOpenResponsesBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
+                }
                 const routeCredential = resolveRouteCredential({
                     optionsApiKey: options?.apiKey,
                     optionsHeaders: options?.headers,
@@ -243,10 +248,6 @@ export function createOpenResponsesBrain(config = {}) {
                 if (!routeVerdict.ok)
                     throw new BrainError("invalid_request", routeRefusalText(routeVerdict));
                 const apiKey = routeCredential.apiKey;
-                const root = (model.baseUrl || config.baseUrl || "").replace(/\/+$/, "");
-                if (!root) {
-                    throw new Error("createOpenResponsesBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
-                }
                 if (options?.stop !== undefined && options.stop.length > 0) {
                     throw new Error("createOpenResponsesBrain: options.stop is not expressible in the Open Responses request (the wire form has no stop-sequence field); " +
                         "remove it, or serve this model through the chat-completions lane, which does support it");

package/dist/brain/openai.js

@@ -7,7 +7,7 @@ import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
 import { OPENAI_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, effectiveOutputCap, lockHeader, mergeHeaders } from "./request-params.js";
 import { BrainError } from "./errors.js";
-import { adjudicateModelRoute, applyRouteCredentialHeaders, createBrainRouteJudge, resolveRouteCredential, routeRefusalText } from "./route-adjudicator.js";
+import { adjudicateModelRoute, applyRouteCredentialHeaders, assertServableRequestRoot, createBrainRouteJudge, resolveRequestRoot, resolveRouteCredential, routeRefusalText } from "./route-adjudicator.js";
 import { declaredOffSpelling, mintEffortWireValue, reasoningRequestCarried } from "./reasoning.js";
 import { runStreamingBrain } from "./stream-engine.js";
 function closeToolCallAccum(acc) {
@@ -281,6 +281,7 @@ export function inferMaxTokensField(modelId) {
     return "max_tokens";
 }
 export function createOpenAIBrain(config = {}) {
+    assertServableRequestRoot(config.baseUrl, "config.baseUrl");
     const doFetch = config.fetchImpl ?? fetch;
     const stream = (model, context, options) => {
         let sentMaxTokens;
@@ -295,6 +296,10 @@ export function createOpenAIBrain(config = {}) {
             httpLabel: "gateway",
             stallTimeouts: options?.stallTimeouts,
             buildRequest: (overrides) => {
+                const root = resolveRequestRoot(model.baseUrl, config.baseUrl);
+                if (!root) {
+                    throw new Error("createOpenAIBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
+                }
                 const routeCredential = resolveRouteCredential({
                     optionsApiKey: options?.apiKey,
                     optionsHeaders: options?.headers,
@@ -306,10 +311,6 @@ export function createOpenAIBrain(config = {}) {
                 if (!routeVerdict.ok)
                     throw new BrainError("invalid_request", routeRefusalText(routeVerdict));
                 const apiKey = routeCredential.apiKey;
-                const root = (model.baseUrl || config.baseUrl || "").replace(/\/+$/, "");
-                if (!root) {
-                    throw new Error("createOpenAIBrain: no baseUrl configured (set config.baseUrl or model.baseUrl)");
-                }
                 const body = {
                     model: model.id,
                     messages: toOpenAIMessages(context, config.replayThinking, model),

package/dist/brain/route-adjudicator.d.ts

@@ -27,29 +27,64 @@
  *    deployment root — a distinct endpoint with no credential route is a configuration hole, and a
  *    loud refusal with a fix hint beats an unauthenticated request to a third-party host.
  *
- * Fail-closed direction: "no credential leak" outranks "silently works". A deployment that only
- * worked because the gateway key HAPPENED to be valid at another entry's host now refuses loudly,
- * and every refusal names the entry, both URL halves, and a one-line fix.
+ * Fail-closed direction: "no credential leak" outranks "silently works", and every refusal names the
+ * entry, both URL halves, and a one-line fix.
  *
- * Bad-value loudness (garbage / contradiction / absence):
+ * Bad-value loudness (garbage / contradiction / absence / misplacement):
  *  - garbage — non-string URL/credential inputs throw a `TypeError` here (a programmer error must
  *    not be laundered into a polite verdict); whitespace-only URLs normalize to "" (undeclared).
  *  - contradiction — the torn pair refuses with `route.credential_mismatch` + both halves named.
  *  - absence — `route.credential_missing` with the fix hint, exactly where absence is a hole.
+ *  - misplacement — a credential in the URL, or a non-http(s) root: {@link assertServableRequestRoot}.
  */
 import type { Model } from "../internal/llm.js";
 import type { RouteAdjudication, RouteCredential, RoutePairingConfig, RoutePairingPosture } from "../internal/llm.js";
 import type { Brain, EngineNotice } from "../core/types.js";
-/** Normalize a base URL for pairing comparison, to WIRE equivalence: trim + strip trailing
- *  slashes, then — for a string that parses as a URL — fold the halves the wire itself treats as
- *  case-insensitive (scheme and host, RFC 9110) and elide the scheme's default port, while keeping
- *  the PATH byte-preserved (paths are case-sensitive; folding them would compare two genuinely
- *  different endpoints equal — a widening of exactly the leak this module exists to stop). Two
- *  spellings that resolve to the same origin+path on the wire therefore compare equal, and a
- *  refusal can never be minted over a spelling difference the wire cannot see. A value that does
- *  not parse as a URL keeps the raw trimmed spelling — the same fail-closed raw comparison as
- *  before. Non-string input throws — see the module note on garbage. */
-export declare function normalizeBaseUrl(url: string | undefined): string;
+/** A base URL's ROUTE KEY — the value the pairing law COMPARES, folded to WIRE equivalence: the
+ *  halves the wire itself treats as case-insensitive (scheme and host, RFC 9110) fold, the scheme's
+ *  default port elides, and PATH and QUERY ride byte-preserved (a query selects the endpoint as
+ *  surely as a path does; folding either would compare two different endpoints equal — the widening
+ *  this module exists to stop). An unparseable value keeps its raw trimmed spelling: fail-closed raw
+ *  comparison. Non-string input throws — see the module note on garbage.
+ *
+ *  **Never render this.** Byte-preserving on the query means `?api_key=<secret>` rides it verbatim;
+ *  {@link displayUrlOf} is the one spelling allowed into text. */
+export declare function routeKeyOf(url: string | undefined): string;
+/** A base URL's DISPLAY spelling — the only rendering of a request root allowed into text a human,
+ *  a log or a consumer sees. Composed from the PARSE (never edited out of raw bytes): userinfo
+ *  drops, EVERY query value becomes {@link REDACTED_VALUE}, and a query NAME rides only where it
+ *  really is a name.
+ *   - no secret-name list: a list has a blind spot at the name nobody listed.
+ *   - names ride because dropping the query WHOLE renders two roots differing only in query as one
+ *     string — exactly the pairs the law refuses, so its refusal would read "targets X … paired
+ *     with X". {@link queryDifferenceNote} closes the case where the names match too.
+ *   - a BARE token (`?<token>`) renders as one placeholder with NO name: `URLSearchParams` calls it a
+ *     name with an empty value, and that reading put the payload itself on screen. "Every value is
+ *     withheld" protects only what IS a value, so the raw segment decides what rides.
+ *  Answers `""` for an undeclared root, like its key twin. */
+export declare function displayUrlOf(url: string | undefined): string;
+/**
+ * The bad-value refusal every base-URL seat owes: **a request root must be an absolute http(s) URL, and
+ * it may not carry the credential itself.**
+ *
+ * Both halves fail the same way if they are not caught here — as a TRANSPORT failure, indistinguishable
+ * from an outage, retried for the whole backoff ladder. Measured: `file:`/`ftp:` reject with
+ * `TypeError("fetch failed")` over a causeless "unknown scheme", the exact shell a refused connection uses.
+ * Stripping userinfo instead of refusing would send an UNAUTHENTICATED request to the host the operator
+ * thought they had authenticated to. Refused where the value ARRIVES — construction for `config.baseUrl`,
+ * request build for `Model.baseUrl`. An undeclared root is not this rule's question; the PAIRING law keeps
+ * its tolerance for an unparseable spelling ({@link routeKeyOf}). Answers the value it judged.
+ */
+export declare function assertServableRequestRoot(url: string | undefined, seat: string): string | undefined;
+/** Remove the userinfo from every authority in free text, WHOLE — the general redactor keeps a short or
+ *  unprefixed username, and `TOKEN@host` / `TOKEN:x-oauth-basic@host` are the canonical PAT spellings. */
+export declare function stripUrlCredentials(text: string): string;
+/** The request ROOT a brain targets — `Model.baseUrl` else `config.baseUrl` else the lane's default,
+ *  trailing slashes stripped — with {@link assertServableRequestRoot} applied to both declared
+ *  halves on the way. The three brains each carried a copy of this coalesce-and-strip line, so a rule
+ *  about base URLs had three homes; now it has one. Answers `""` when nothing is declared and the lane
+ *  has no default — whether that is a refusal is the caller's. */
+export declare function resolveRequestRoot(modelBaseUrl: string | undefined, configBaseUrl: string | undefined, laneDefault?: string): string;
 /** Whether a header bag carries an auth-bearing header (any case). */
 export declare function hasAuthCarrier(headers: Record<string, string> | undefined): boolean;
 /**
@@ -168,7 +203,7 @@ export declare function adjudicateDerivedRoute(args: {
 }): Promise<RouteAdjudication | undefined>;
 /**
  * Whether two resolved models denote the SAME route for pre-flight purposes: identical wire id AND
- * identical normalized entry URL. `Model.id` alone is NOT route identity — two catalog entries can
+ * identical entry ROUTE KEY. `Model.id` alone is NOT route identity — two catalog entries can
  * legitimately share a wire id (the same model served from two endpoints), and a same-id guard
  * would silently skip the pre-flight for exactly the split the pairing law exists to judge.
  */

package/dist/brain/route-adjudicator.js

@@ -1,5 +1,28 @@
 import { AUTH_CARRIER_NAMES } from "./request-params.js";
-export function normalizeBaseUrl(url) {
+import { BrainError } from "./errors.js";
+const REDACTED_VALUE = "«redacted»";
+const REDACTED_CREDENTIALS = "[redacted-credentials]";
+function servableParse(raw) {
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        return undefined;
+    }
+    return u.protocol === "http:" || u.protocol === "https:" ? u : undefined;
+}
+function composableParse(raw) {
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        return undefined;
+    }
+    return u.host !== "" || u.pathname.startsWith("/") ? u : undefined;
+}
+export function routeKeyOf(url) {
     if (url === undefined)
         return "";
     if (typeof url !== "string") {
@@ -8,13 +31,78 @@ export function normalizeBaseUrl(url) {
     const raw = url.trim().replace(/\/+$/, "");
     if (raw === "")
         return "";
-    try {
-        const u = new URL(raw);
-        return `${u.protocol}//${u.host}${u.pathname}${u.search}`.replace(/\/+$/, "");
-    }
-    catch {
+    const u = servableParse(raw);
+    if (u === undefined)
         return raw;
+    return `${u.protocol}//${u.host}${u.pathname}${u.search}`.replace(/\/+$/, "");
+}
+function querySegments(search) {
+    if (search === "" || search === "?")
+        return [];
+    return search.replace(/^\?/, "").split("&").map((raw) => {
+        const eq = raw.indexOf("=");
+        return eq === -1 ? { raw } : { raw, name: raw.slice(0, eq), value: raw.slice(eq + 1) };
+    });
+}
+export function displayUrlOf(url) {
+    const key = routeKeyOf(url);
+    if (key === "")
+        return "";
+    const u = composableParse(key);
+    if (u === undefined) {
+        const cut = key.search(/[?#]/);
+        const head = cut === -1 ? key : key.slice(0, cut);
+        const at = head.lastIndexOf("@");
+        const shown = at === -1 ? head : `${REDACTED_VALUE}@${head.slice(at + 1)}`;
+        return cut === -1 ? shown : `${shown}${key[cut]}${REDACTED_VALUE}`;
     }
+    const segs = querySegments(u.search);
+    const query = segs.length === 0 ? "" : `?${segs.map((sg) => (sg.raw === "" ? "" : sg.name === undefined ? REDACTED_VALUE : `${sg.name}=${REDACTED_VALUE}`)).join("&")}`;
+    return `${u.protocol}//${u.host}${u.pathname}${query}`.replace(/\/+$/, "");
+}
+function queryDifferenceNote(requestKey, declaredKey) {
+    if (displayUrlOf(requestKey) !== displayUrlOf(declaredKey))
+        return "";
+    const names = new Set();
+    const ua = composableParse(requestKey);
+    const ub = composableParse(declaredKey);
+    if (ua !== undefined && ub !== undefined) {
+        const a = querySegments(ua.search);
+        const b = querySegments(ub.search);
+        const valuesOf = (segs, n) => segs.filter((sg) => sg.name === n).map((sg) => sg.value).join("\u0000");
+        for (const n of new Set([...a, ...b].flatMap((sg) => (sg.name === undefined ? [] : [sg.name])))) {
+            if (valuesOf(a, n) !== valuesOf(b, n))
+                names.add(n);
+        }
+    }
+    return names.size > 0
+        ? ` (same rendering — the query values differ under: ${[...names].sort().join(", ")})`
+        : ` (same rendering — the difference is in a part this line withholds or folds)`;
+}
+export function assertServableRequestRoot(url, seat) {
+    if (typeof url !== "string" || url.trim() === "")
+        return undefined;
+    const trimmed = url.trim();
+    const parsed = URL.canParse(trimmed) ? new URL(trimmed) : undefined;
+    if (parsed === undefined || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+        const named = parsed === undefined ? "it did not parse as a URL" : displayUrlOf(trimmed);
+        throw new BrainError("invalid_request", `${seat} is not a servable request root (${named}) — it must be an ABSOLUTE http(s) URL. Another scheme, ` +
+            `or a spelling that is not a URL at all, fails at the transport in a shape indistinguishable from an ` +
+            `outage, so it would be retried for the whole backoff ladder instead of refused here.`);
+    }
+    if (parsed.username === "" && parsed.password === "")
+        return trimmed;
+    throw new BrainError("invalid_request", `${seat} carries credentials in its authority (${parsed.protocol}//${REDACTED_CREDENTIALS}@${parsed.host}${parsed.pathname}) — ` +
+        `a request cannot be built from a URL with userinfo, so every call through this brain would fail: put the ` +
+        `credential on the apiKey knob or an auth header and leave the URL bare`);
+}
+export function stripUrlCredentials(text) {
+    return text.replace(/([A-Za-z][A-Za-z0-9+.\-]*:\/\/)[^/\s"'@]*@/g, `$1${REDACTED_CREDENTIALS}@`);
+}
+export function resolveRequestRoot(modelBaseUrl, configBaseUrl, laneDefault = "") {
+    const entry = assertServableRequestRoot(modelBaseUrl, "Model.baseUrl");
+    const declared = assertServableRequestRoot(configBaseUrl, "config.baseUrl");
+    return (entry ?? declared ?? laneDefault).replace(/\/+$/, "");
 }
 export function hasAuthCarrier(headers) {
     if (!headers)
@@ -50,9 +138,12 @@ export function resolveRouteCredential(input) {
     return { source: "absent" };
 }
 export function adjudicateModelRoute(model, credential, config) {
-    const entry = normalizeBaseUrl(model.baseUrl);
-    const declared = normalizeBaseUrl(config.baseUrl);
+    const entry = routeKeyOf(model.baseUrl);
+    const declared = routeKeyOf(config.baseUrl);
     const request = entry || declared;
+    const entryShown = displayUrlOf(entry);
+    const declaredShown = displayUrlOf(declared);
+    const requestShown = displayUrlOf(request);
     if (credential.source === "per-model")
         return { ok: true, posture: "per-model" };
     if (credential.source === "deployment-config") {
@@ -65,12 +156,13 @@ export function adjudicateModelRoute(model, credential, config) {
             code: "route.credential_mismatch",
             detail: {
                 modelId: model.id,
-                entryBaseUrl: entry,
-                requestBaseUrl: request,
-                configBaseUrl: declared,
-                fixHint: `model "${model.id}" targets ${request} but the deployment credential is paired with ${declared}: ` +
+                entryBaseUrl: entryShown,
+                requestBaseUrl: requestShown,
+                configBaseUrl: declaredShown,
+                fixHint: `model "${model.id}" targets ${requestShown} but the deployment credential is paired with ${declaredShown}` +
+                    `${queryDifferenceNote(request, declared)}: ` +
                     `give the model its own credential (a per-model key via getApiKeyAndHeaders, or an auth header on Model.headers), ` +
-                    `or serve it through a brain whose config.baseUrl is ${request}`,
+                    `or serve it through a brain whose config.baseUrl is the model's own root`,
             },
         };
     }
@@ -81,12 +173,12 @@ export function adjudicateModelRoute(model, credential, config) {
         code: "route.credential_missing",
         detail: {
             modelId: model.id,
-            entryBaseUrl: entry,
-            requestBaseUrl: request,
-            configBaseUrl: declared,
-            fixHint: `model "${model.id}" targets ${request} but no credential is configured for that endpoint ` +
-                `(the deployment credential root is ${declared}): supply a per-model credential ` +
-                `(getApiKeyAndHeaders, or an auth header on Model.headers), or serve it through a brain constructed for ${request}`,
+            entryBaseUrl: entryShown,
+            requestBaseUrl: requestShown,
+            configBaseUrl: declaredShown,
+            fixHint: `model "${model.id}" targets ${requestShown} but no credential is configured for that endpoint ` +
+                `(the deployment credential root is ${declaredShown})${queryDifferenceNote(request, declared)}: supply a per-model credential ` +
+                `(getApiKeyAndHeaders, or an auth header on Model.headers), or serve it through a brain constructed for that root`,
         },
     };
 }
@@ -166,7 +258,7 @@ export async function adjudicateDerivedRoute(args) {
     }
 }
 export function sameRouteIdentity(a, b) {
-    return a.id === b.id && normalizeBaseUrl(a.baseUrl) === normalizeBaseUrl(b.baseUrl);
+    return a.id === b.id && routeKeyOf(a.baseUrl) === routeKeyOf(b.baseUrl);
 }
 export function fallbackToPrimaryNotice(args) {
     return {

package/dist/brain/route-conformance.js

@@ -73,6 +73,15 @@ export const ROUTE_ADJUDICATION_CONFORMANCE_CORPUS = [
         expect: { ok: false, code: "route.credential_mismatch" },
         leg: "named",
     },
+    {
+        name: "deployment-mismatch-query-differs",
+        intent: "two roots differing only in a QUERY parameter are two routes — the deployment credential is not paired with the second",
+        model: { id: "m-tenant", baseUrl: "https://gw.example.com/v1?tenant=b-corp" },
+        credential: { source: "deployment-config", apiKey: "k-boot" },
+        config: { baseUrl: "https://gw.example.com/v1?tenant=a-corp" },
+        expect: { ok: false, code: "route.credential_mismatch" },
+        leg: "named",
+    },
     {
         name: "deployment-mismatch-derived-leg",
         intent: "the same torn pair on a DERIVED model: same verdict; the engine disposes of it as fallback-to-primary + notice",

package/dist/brain/stream-engine.js

@@ -1,12 +1,14 @@
 import { createAssistantMessageEventStream, } from "../internal/llm.js";
 import { STREAM_TORN_WARNING } from "./stream-shared.js";
 import { FLOOR_OUTPUT_TOKENS, parseContextOverflow, planOutputCapAdjustment } from "./context-overflow.js";
-import { BrainError, classifyConnectFailure, classifyHttp, describeNetworkError, namesTheFailure, readProviderRequestId } from "./errors.js";
+import { abortLikeName, BrainError, brainErrorCodeOf, classifyConnectFailure, classifyFetchThrow, classifyHttp, describeNetworkError, namesTheFailure, readProviderRequestId } from "./errors.js";
+import { stripUrlCredentials } from "./route-adjudicator.js";
 import { classifyInputTooLong } from "./input-too-long.js";
 import { FAST_MAX_BACKOFF_MS, providerWaitHint, retryBackoffMs } from "./retry.js";
 import { bindBrainStatusEmitter, emitBrainStatus, emitBrainTelemetry } from "./status-sink.js";
 import { createConnectController, resolveStallTimeoutMs } from "./timeout.js";
-import { thrownText } from "../core/thrown-value.js";
+import { readMember, thrownText } from "../core/thrown-value.js";
+import { redactSecrets } from "../core/untrusted-egress.js";
 const DEFAULT_MAX_RETRIES = 10;
 const MAX_RETRIES_ENV_CEILING = 15;
 const MAX_RETRIES_ENV = "SEMA_MAX_RETRIES";
@@ -215,7 +217,7 @@ function emptyAssistant(model) {
     };
 }
 function isAbortError(err) {
-    return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+    return abortLikeName(err) !== undefined;
 }
 function sleep(ms, signal) {
     return new Promise((resolve) => {
@@ -272,15 +274,17 @@ export function runStreamingBrain(args) {
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = thrownText(err);
-        if (!aborted && err instanceof BrainError) {
-            if (err.inputTooLong === true)
+        if (!aborted && brainErrorCodeOf(err) !== undefined) {
+            if (readMember(err, "inputTooLong") === true)
                 errorMsg.errorKind = "input_too_long";
-            else if (err.inputTooLongRuledOut === true)
+            else if (readMember(err, "inputTooLongRuledOut") === true)
                 errorMsg.inputTooLongRuledOut = true;
-            if (err.apiError === true) {
+            if (readMember(err, "apiError") === true) {
                 errorMsg.isApiErrorMessage = true;
-                if (namesTheFailure(err.status))
-                    errorMsg.apiErrorStatus = err.status;
+                const status = readMember(err, "status");
+                const statusNum = typeof status === "number" ? status : undefined;
+                if (namesTheFailure(statusNum))
+                    errorMsg.apiErrorStatus = statusNum;
                 if (requestIdSeen !== undefined)
                     errorMsg.requestId = requestIdSeen;
             }
@@ -338,6 +342,10 @@ export function runStreamingBrain(args) {
                         cc.dispose();
                         throw e;
                     }
+                    else if (classifyFetchThrow(e) === "request_unbuildable") {
+                        cc.dispose();
+                        throw new BrainError("invalid_request", `${httpLabel} request could not be built: ${redactSecrets(stripUrlCredentials(thrownText(e)))}`);
+                    }
                     else {
                         netErr = e;
                     }
@@ -575,7 +583,7 @@ export function runStreamingBrain(args) {
                     return false;
                 }
                 catch (e) {
-                    if (!(e instanceof BrainError) || e.code !== "server" || !parser.snapshot().hasSubstantiveText)
+                    if (brainErrorCodeOf(e) !== "server" || !parser.snapshot().hasSubstantiveText)
                         throw e;
                     return true;
                 }

package/dist/core/arg-summary.js

@@ -196,14 +196,15 @@ export function runRedactionPasses(input, passes, report) {
     return result;
 }
 export const SECRET_PASSES = [
-    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])(?:sk|pk|rk|gh[opsur])[-_][A-Za-z0-9_-]{8,}/g, replace: "[redacted]" },
+    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])(?:sk|pk|rk|gh[opsur]|github_pat)[-_][A-Za-z0-9_-]{8,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])AIza[A-Za-z0-9_-]{20,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])xox[baprs]-[A-Za-z0-9-]{10,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{12,}/g, replace: "[redacted]" },
     { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{20,}/g, replace: "[redacted]" },
     { kind: "jwt", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])eyJ[A-Za-z0-9._-]{20,}/g, replace: "[redacted]" },
-    { kind: "private-key-block", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /-----BEGIN[ A-Z]*PRIVATE KEY-----[\s\S]*?(?:-----END[ A-Z]*PRIVATE KEY-----|$)/g, replace: "[redacted]" },
+    { kind: "private-key-block", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /-----BEGIN[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----|$)/g, replace: "[redacted]" },
     { kind: "bearer-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(?<![A-Za-z0-9])Bearer\s+[A-Za-z0-9._~+/-]{8,}=*/gi, replace: "[redacted]" },
+    { kind: "prefixed-token", confidence: "high", marker: "[redacted]", source: "arg-summary", re: /(AccountKey=)[A-Za-z0-9+/]{40,}={0,2}/g, replace: "$1[redacted]" },
     {
         kind: "keyword-value",
         confidence: "medium",
@@ -247,12 +248,22 @@ export function primaryActivityArg(args) {
         val = basename(path);
     }
     else if (url !== undefined) {
-        try {
-            const u = new URL(url);
-            val = `${u.origin}${u.pathname}`;
+        const parsed = (() => { try {
+            return new URL(url);
         }
         catch {
-            val = url.split(/[?#]/)[0].replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1");
+            return undefined;
+        } })();
+        if (parsed !== undefined && parsed.host !== "") {
+            val = `${parsed.origin}${parsed.pathname}`;
+        }
+        else {
+            const head = url.split(/[?#]/, 1)[0] ?? url;
+            const sep = head.indexOf("://");
+            const scheme = sep > 0 && /^[a-z][a-z0-9+.-]*$/i.test(head.slice(0, sep)) ? head.slice(0, sep + 3) : "";
+            const rest = head.slice(scheme.length);
+            const at = rest.lastIndexOf("@");
+            val = scheme + (at === -1 ? rest : rest.slice(at + 1));
         }
     }
     else {