@sigrun/provider-bifrost 0.1.2 → 0.2.1

package/CHANGELOG.md

@@ -11,8 +11,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   provenance. No functional change from 0.1.0.
 
 ## [Unreleased]
+
+## [0.2.1] - 2026-11-03
+### Fixed
+- Replies from chain models persist the `chain/` display id, so clients can
+  show where a message came from. Outgoing history is replayed under the
+  wire name, so chain models keep their thinking blocks and signatures.
+  Usage is now keyed `bifrost/chain/<name>`; earlier usage stays under
+  `bifrost/<name>`.
+
+## [0.2.0] - 2026-10-30
 ### Changed
-- Forward-compatible with pi-durable 1.4.0 (widened peer range). No behaviour change.
+- **Breaking:** chain model references change from `bifrost/bifrost/<chain>`
+  to `bifrost/chain/<chain>` (plugin id `chain/<chain>`). The gateway
+  receives the bare chain name.
+- Member ids are unchanged; upstream catalog entries in the reserved
+  `chain/` display namespace are skipped with one warning per process.
+- Forward-compatible with pi-durable 1.4.0 (widened peer range).
 
 ## [0.1.0] - 2026-10-18
 ### Changed

package/README.md

@@ -26,11 +26,14 @@ the provider into its `Models` store at boot.
     queried too: the VK self-identifies against
     `/api/governance/virtual-keys` (the credential value matched to VK
     rows), then `/api/routing/rules?scope=virtual_key&scope_id=<vk>`
-    yields the chain rules; every usable chain publishes as
-    `bifrost/<chain>` (min-member context window, cost 0 by design —
-    the gateway's own `/api/logs` is the billing system of record),
+    yields the chain rules; every usable chain publishes with plugin id
+    `chain/<name>` (displayed by sigrun as `bifrost/chain/<name>`, with
+    min-member context window and cost 0 by design). Requests to the
+    gateway carry the bare `<name>`, never the `chain/` display prefix.
+    The gateway's own `/api/logs` is the billing system of record,
     optionally followed by the upstream catalog (`publishUpstream`,
-    default true).
+    default true). Upstream `/v1/models` entries under the reserved
+    `chain/` namespace are skipped as direct members.
 - **Readiness** (`not_configured` / `degraded` / `ready`, surfaced on
   sigrun's `/v1/auth/check`) — seeded from credential resolution and
   updated per refresh outcome; state transitions log via `console.warn`
@@ -126,7 +129,7 @@ and `not_configured` readiness.
 ```jsonc
 // settings.json (sigrun config dir) — the UNIFIED extensions list:
 // install + load in one place; npm and git specifiers are the same list
-// npm ("@sigrun/provider-bifrost@^0.1.0"), git
+// npm ("@sigrun/provider-bifrost@^0.2.0"), git
 // ("git:github.com/sigrun-ai/sigrun-provider-bifrost", or any
 // https git URL with an optional @ref), or the file: form below.
 {

package/dist/catalog.d.ts

@@ -14,6 +14,8 @@ import { type FetchJsonOptions } from "./http.js";
 import type { NativeProtocols } from "./config.js";
 /** The provider id models are registered (and stamped) under. */
 export declare const PROVIDER_ID = "bifrost";
+/** Sigrun-side chain display namespace; never sent to the gateway. */
+export declare const CHAIN_ID_PREFIX = "chain/";
 export declare const PROVIDER_DISPLAY_NAME = "Bifrost Gateway";
 /** Different relative to the configured /v1 base URL. */
 export declare const INFERENCE_PATH_MODELS = "models";
@@ -220,13 +222,15 @@ export declare function wireRulesToChains(rules: RoutingRule[]): Chain[];
 /** Convert a $/token wire string to pi's $/Mtok rate. */
 export declare function perMtok(dollarsPerToken: string): number | undefined;
 /**
- * Build one bifrost/<chain> chat model per chain. Cost is 0 by design. The
+ * Build one chain/<name> display model per chain. Cost is 0 by design. The
  * wire follows the chain's model-family (native protocol end to end): the
  * chain name decides — fallback legs of a chain are same-model by
  * construction, and the gateway translates any client wire for legs that
  * differ.
  */
 export declare function buildChainModels(chains: Chain[], catalog: CatalogModel[], providerSlug: string, baseUrl: string, native?: NativeProtocols): GatewayModel[];
+/** Catalog entries that collide with the reserved chain display namespace. */
+export declare function collidingMemberIds(catalog: readonly CatalogModel[]): string[];
 /**
  * Build direct-selectable models for the /v1/models catalog with real
  * per-member pricing, ordered with chain members first.

package/dist/catalog.js

@@ -18,6 +18,8 @@ import { fetchJson } from "./http.js";
 /* ---------- gateway constants (pi port's src/bifrost.ts) ---------- */
 /** The provider id models are registered (and stamped) under. */
 export const PROVIDER_ID = "bifrost";
+/** Sigrun-side chain display namespace; never sent to the gateway. */
+export const CHAIN_ID_PREFIX = "chain/";
 export const PROVIDER_DISPLAY_NAME = "Bifrost Gateway";
 /** Different relative to the configured /v1 base URL. */
 export const INFERENCE_PATH_MODELS = "models";
@@ -78,7 +80,7 @@ function bareModelName(id) {
     // Strip legacy managed prefixes (gateway/, bifrost/) if a rule CEL ever
     // produces a prefixed bare name; MANAGED_PREFIXES itself is private to CEL
     // decoding, so this local strip keeps the denylist honest at both call sites.
-    return noPrefix.replace(/^(gateway|bifrost)\//, "");
+    return noPrefix.replace(/^(gateway|bifrost|chain)\//, "");
 }
 function inputFor(id) {
     return TEXT_ONLY_MODELS.has(bareModelName(id)) ? [...TEXT_ONLY_MODALITIES] : [...INPUT_MODALITIES];
@@ -231,7 +233,7 @@ export async function wireDiscovery(managementToken, vkValue, baseUrl, scopeId,
 }
 /* ---------- chain decoding (pure) ---------- */
 /** Managed model-id prefixes that strip to the bare chain name. */
-const MANAGED_PREFIXES = ["bifrost", "gateway"];
+const MANAGED_PREFIXES = ["bifrost", "gateway", "chain"];
 /**
  * Extract a chain model name from a routing rule's CEL expression.
  * Recognizes `model == "x"` arms and strips managed prefixes (`bifrost/`,
@@ -313,7 +315,7 @@ function thinkingLevelMap(api, levels) {
     return map;
 }
 /**
- * Build one bifrost/<chain> chat model per chain. Cost is 0 by design. The
+ * Build one chain/<name> display model per chain. Cost is 0 by design. The
  * wire follows the chain's model-family (native protocol end to end): the
  * chain name decides — fallback legs of a chain are same-model by
  * construction, and the gateway translates any client wire for legs that
@@ -328,7 +330,7 @@ export function buildChainModels(chains, catalog, providerSlug, baseUrl, native)
             .filter((v) => typeof v === "number");
         const contextWindow = contexts.length > 0 ? Math.min(...contexts) : CONTEXT_WINDOW_FALLBACK;
         return buildModel({
-            id: `${providerSlug}/${chain.name}`,
+            id: `${CHAIN_ID_PREFIX}${chain.name}`,
             name: chain.name,
             familyId: chain.name,
             provider: providerSlug,
@@ -383,6 +385,10 @@ function buildModel(args) {
     };
     return model;
 }
+/** Catalog entries that collide with the reserved chain display namespace. */
+export function collidingMemberIds(catalog) {
+    return catalog.filter((entry) => entry.id.startsWith(CHAIN_ID_PREFIX)).map((entry) => entry.id);
+}
 /**
  * Build direct-selectable models for the /v1/models catalog with real
  * per-member pricing, ordered with chain members first.
@@ -407,6 +413,8 @@ export function buildMemberModels(chains, catalog, providerSlug, baseUrl, thinki
     }
     const models = [];
     for (const memberId of memberIds) {
+        if (memberId.startsWith(CHAIN_ID_PREFIX))
+            continue;
         const entry = byId.get(memberId);
         if (!entry)
             continue; // chain member absent from /v1/models — skip rather than guess

package/dist/config.d.ts

@@ -36,7 +36,7 @@ export interface NativeProtocols {
     messagesModels?: string[];
 }
 export interface BifrostSettings {
-    /** Emit chain models (bifrost/<chain>) from the VK's routing rules. */
+    /** Emit chain models (chain/<name>) from the VK's routing rules. */
     publishChains: boolean;
     /** Emit all upstream models from /v1/models as direct-selectable entries. */
     publishUpstream: boolean;

package/dist/index.d.ts

@@ -42,11 +42,12 @@
  */
 import { type Provider } from "@earendil-works/pi-ai/models";
 import { type NativeProtocols } from "./config.js";
-import { PROVIDER_DISPLAY_NAME, PROVIDER_ID, UNRESOLVED_BASE_URL, type GatewayModel } from "./catalog.js";
-export { PROVIDER_ID, PROVIDER_DISPLAY_NAME, UNRESOLVED_BASE_URL };
+import { PROVIDER_DISPLAY_NAME, PROVIDER_ID, UNRESOLVED_BASE_URL, CHAIN_ID_PREFIX, type GatewayModel } from "./catalog.js";
+export { PROVIDER_ID, PROVIDER_DISPLAY_NAME, UNRESOLVED_BASE_URL, CHAIN_ID_PREFIX };
 export { parseBifrostSettings, BIFROST_BASE_URL_ENV } from "./config.js";
 export type { BifrostSettings, NativeProtocols } from "./config.js";
 export type { GatewayModel, SurfaceApi, CatalogModel, Chain, RoutingRule } from "./catalog.js";
+export { chainWireName, withWireNames } from "./wire.js";
 /** Ambient fallback for the virtual key when auth.json holds no credential. */
 export declare const BIFROST_API_KEY_ENV = "BIFROST_API_KEY";
 /**

package/dist/index.js

@@ -45,16 +45,25 @@ import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completio
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
 import { BIFROST_BASE_URL_ENV, parseBifrostSettings, } from "./config.js";
-import { PROVIDER_DISPLAY_NAME, PROVIDER_ID, UNRESOLVED_BASE_URL, buildAllModels, wireCatalog, wireDiscovery, wireRulesToChains, wireScopeId, } from "./catalog.js";
+import { PROVIDER_DISPLAY_NAME, PROVIDER_ID, UNRESOLVED_BASE_URL, CHAIN_ID_PREFIX, buildAllModels, collidingMemberIds, wireCatalog, wireDiscovery, wireRulesToChains, wireScopeId, } from "./catalog.js";
+import { withWireNames } from "./wire.js";
 // Re-exported gateway constants (the pi port's src/bifrost.ts surface):
 // the provider id is part of this plugin's public contract — sigrun's
 // auth-check names providers by id and tests pin the model stamp to it.
-export { PROVIDER_ID, PROVIDER_DISPLAY_NAME, UNRESOLVED_BASE_URL };
+export { PROVIDER_ID, PROVIDER_DISPLAY_NAME, UNRESOLVED_BASE_URL, CHAIN_ID_PREFIX };
 // Re-exported discovery/config types so consumers (and tests) need no
 // deep imports.
 export { parseBifrostSettings, BIFROST_BASE_URL_ENV } from "./config.js";
+export { chainWireName, withWireNames } from "./wire.js";
 /** Ambient fallback for the virtual key when auth.json holds no credential. */
 export const BIFROST_API_KEY_ENV = "BIFROST_API_KEY";
+let chainNamespaceWarned = false;
+function warnOnChainNamespaceCollision(catalog) {
+    if (chainNamespaceWarned || collidingMemberIds(catalog).length === 0)
+        return;
+    console.warn('bifrost: upstream provider "chain" collides with the chain display namespace; its models are skipped');
+    chainNamespaceWarned = true;
+}
 /**
  * Compose the gateway model list from live Bifrost state (the ported
  * `discoverModels` with sigrun's failure semantics — throws instead of
@@ -85,6 +94,7 @@ export async function discoverModels(token, baseUrl, options, signal) {
             throw new Error("provider-bifrost: credential does not match any virtual key in /api/governance/virtual-keys");
         }
         const { catalog, rules } = await wireDiscovery(managementToken, token, baseUrl, scopeId, signal);
+        warnOnChainNamespaceCollision(catalog);
         const chains = wireRulesToChains(rules);
         if (chains.length === 0) {
             throw new Error(`provider-bifrost: no chain routing rules found for ${scopeId} — is chains-first routing configured for this VK?`);
@@ -100,6 +110,7 @@ export async function discoverModels(token, baseUrl, options, signal) {
         throw new Error("provider-bifrost: publishChains and publishUpstream are both false — nothing to publish");
     }
     const catalog = await wireCatalog(token, baseUrl, signal);
+    warnOnChainNamespaceCollision(catalog);
     const models = buildAllModels([], catalog, PROVIDER_ID, baseUrl, false, true, options.thinkingOverrides, options.nativeProtocols);
     if (models.length === 0) {
         throw new Error("provider-bifrost: /v1/models returned no usable entries; refusing to publish an empty catalog");
@@ -124,6 +135,7 @@ export function createBifrostPlugin(options) {
     // The ambient base URL, captured at credential resolution (the only
     // place the env seam is available); the baked settings URL outranks it.
     let ambientBaseUrl;
+    const wireNames = new Map();
     function status() {
         if (!credentialResolved)
             return "not_configured";
@@ -199,9 +211,9 @@ export function createBifrostPlugin(options) {
         // default). The map always registers all three: the registry entry
         // is inert for models that never publish that api.
         api: {
-            "openai-completions": openAICompletionsApi(),
-            "openai-responses": openAIResponsesApi(),
-            "anthropic-messages": anthropicMessagesApi(),
+            "openai-completions": withWireNames(openAICompletionsApi(), wireNames),
+            "openai-responses": withWireNames(openAIResponsesApi(), wireNames),
+            "anthropic-messages": withWireNames(anthropicMessagesApi(), wireNames),
         },
         fetchModels: async (context) => {
             const key = context.credential?.type === "api_key"
@@ -214,6 +226,11 @@ export function createBifrostPlugin(options) {
             const url = options.baseUrl ?? ambientBaseUrl;
             try {
                 const models = await discoverModels(key, url, options, context.signal);
+                wireNames.clear();
+                for (const model of models) {
+                    if (model.id.startsWith(CHAIN_ID_PREFIX))
+                        wireNames.set(model.id, model.name);
+                }
                 noteRefresh(true);
                 return models;
             }

package/dist/wire.d.ts

@@ -0,0 +1,19 @@
+import type { Api, AssistantMessageEventStream, Model, ProviderStreams } from "@earendil-works/pi-ai";
+/** Resolve the gateway's model name from a sigrun-side display id. */
+export declare function chainWireName(id: string, known: ReadonlyMap<string, string>): string;
+/**
+ * Restore the sigrun-side display id on a reply.
+ *
+ * The gateway names its reply after the model it was asked for — the bare
+ * wire name (`acme-flash`) — and pi-ai copies that name onto the reply's
+ * messages, so a persisted message from a chain model would forget where it
+ * came from. Every event is forwarded, the terminal `done`/`error` included,
+ * because pi-ai derives `result()` (and `durationMs`) from that event.
+ *
+ * `model` is the request's model; it is optional only because the display id
+ * and wire name already describe the reply. Supply it so a stream that breaks
+ * outright can report an accurate `api`/`provider`.
+ */
+export declare function withDisplayId(stream: AssistantMessageEventStream, displayId: string, wireName: string, model?: Model<Api>): AssistantMessageEventStream;
+/** Keep display ids at the provider boundary and bare names on the gateway wire. */
+export declare function withWireNames(streams: ProviderStreams, known: ReadonlyMap<string, string>): ProviderStreams;

package/dist/wire.js

@@ -0,0 +1,159 @@
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { CHAIN_ID_PREFIX, PROVIDER_ID } from "./catalog.js";
+/** Resolve the gateway's model name from a sigrun-side display id. */
+export function chainWireName(id, known) {
+    const discovered = known.get(id);
+    if (discovered !== undefined)
+        return discovered;
+    return id.startsWith(CHAIN_ID_PREFIX) ? id.slice(CHAIN_ID_PREFIX.length) : id;
+}
+function wireModel(model, known) {
+    return { ...model, id: chainWireName(model.id, known) };
+}
+/**
+ * Fold this model's display id back to the wire name on outgoing history.
+ *
+ * pi-ai replays an assistant turn as "the same model" only when its provider,
+ * api and model all match the request (`transformMessages`), and that gate is
+ * what keeps thinking blocks with their signatures, tool-call thought
+ * signatures, and tool-call ids. The inner implementation replays against the
+ * WIRE model, so a persisted `chain/` reply would otherwise read as a foreign
+ * model's turn and lose every one of those. Only this provider's own turns for
+ * this exact model are renamed: another model's (or another provider's)
+ * history keeps its cross-model semantics.
+ */
+function replayContext(context, model, wireName) {
+    let changed = false;
+    const messages = context.messages.map((message) => {
+        if (message.role !== "assistant")
+            return message;
+        if (message.provider !== model.provider || message.model !== model.id)
+            return message;
+        changed = true;
+        return { ...message, model: wireName };
+    });
+    // Untouched histories cross by reference, so a member request costs nothing.
+    return changed ? { ...context, messages } : context;
+}
+/** The message an event carries, whichever field its variant uses. */
+function eventMessage(event) {
+    switch (event.type) {
+        case "done":
+            return event.message;
+        case "error":
+            return event.error;
+        default:
+            return event.partial;
+    }
+}
+/**
+ * The message a stream that broke outright reports.
+ *
+ * Mirrors pi-ai's own setup-error message (`api/lazy.js`): an empty assistant
+ * reply whose `stopReason` is `"error"` and whose text names the cause. pi-ai
+ * never replays an errored assistant turn, so this message only carries the
+ * failure to the consumer — but it MUST exist, because `EventStream.end()`
+ * without a result leaves `result()` unresolved forever.
+ */
+function failureMessage(cause, displayId, model) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model?.api ?? "unknown",
+        provider: model?.provider ?? PROVIDER_ID,
+        model: displayId,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "error",
+        errorMessage: cause instanceof Error ? cause.message : String(cause),
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Restore the sigrun-side display id on a reply.
+ *
+ * The gateway names its reply after the model it was asked for — the bare
+ * wire name (`acme-flash`) — and pi-ai copies that name onto the reply's
+ * messages, so a persisted message from a chain model would forget where it
+ * came from. Every event is forwarded, the terminal `done`/`error` included,
+ * because pi-ai derives `result()` (and `durationMs`) from that event.
+ *
+ * `model` is the request's model; it is optional only because the display id
+ * and wire name already describe the reply. Supply it so a stream that breaks
+ * outright can report an accurate `api`/`provider`.
+ */
+export function withDisplayId(stream, displayId, wireName, model) {
+    const restored = createAssistantMessageEventStream();
+    void (async () => {
+        try {
+            let result;
+            for await (const event of stream) {
+                const message = eventMessage(event);
+                if (message.model === wireName)
+                    message.model = displayId;
+                // pi-ai resolves result() from the terminal event, so forward it
+                // untouched (the id is already restored) and end() after it.
+                if (event.type === "done")
+                    result = event.message;
+                else if (event.type === "error")
+                    result = event.error;
+                restored.push(event);
+            }
+            // A stream can settle through end(result) without any event; pi-ai's
+            // own forwarder reads that result so result() never hangs.
+            if (result === undefined)
+                result = await stream.result();
+            if (result !== undefined && result.model === wireName)
+                result.model = displayId;
+            restored.end(result);
+        }
+        catch (cause) {
+            // pi-ai streams terminate with an error event and their iterator does
+            // not throw, so this is an upstream contract violation. Report it the
+            // way pi-ai reports a failed setup — a terminal error event — and
+            // settle with that message: ending without a result would leave every
+            // `await stream.result()` waiting forever, and the cause would be lost.
+            const failure = failureMessage(cause, displayId, model);
+            restored.push({ type: "error", reason: "error", error: failure });
+            restored.end(failure);
+        }
+    })();
+    return restored;
+}
+/** Keep display ids at the provider boundary and bare names on the gateway wire. */
+export function withWireNames(streams, known) {
+    /** Replies are named after the request; a stripped id must come back whole. */
+    const restoreReply = (model, wireName, stream) => (wireName === model.id ? stream : withDisplayId(stream, model.id, wireName, model));
+    /**
+     * Cross the boundary once: the request names the wire model, the history
+     * replays under that same name, and the reply keeps the display id.
+     */
+    const delegate = (model, context, call) => {
+        const wireName = chainWireName(model.id, known);
+        const history = wireName === model.id ? context : replayContext(context, model, wireName);
+        return restoreReply(model, wireName, call(wireModel(model, known), history));
+    };
+    const wrapped = {
+        stream: (model, context, options) => delegate(model, context, (wire, history) => streams.stream(wire, history, options)),
+        streamSimple: (model, context, options) => delegate(model, context, (wire, history) => streams.streamSimple(wire, history, options)),
+    };
+    if (streams.fetchDeferred !== undefined) {
+        const fetchDeferred = streams.fetchDeferred;
+        // A deferred fetch replays no history: only the request and reply cross.
+        wrapped.fetchDeferred = (model, handle, options) => {
+            const wireName = chainWireName(model.id, known);
+            return restoreReply(model, wireName, fetchDeferred.call(streams, wireModel(model, known), handle, options));
+        };
+    }
+    if (streams.cancelDeferred !== undefined) {
+        const cancelDeferred = streams.cancelDeferred;
+        wrapped.cancelDeferred = (model, handle, options) => cancelDeferred.call(streams, wireModel(model, known), handle, options);
+    }
+    return wrapped;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@sigrun/provider-bifrost",
-	"version": "0.1.2",
-	"description": "Sigrun provider plugin: a Bifrost LLM gateway as one dynamic provider \u2014 chain models from VK routing rules and/or the upstream catalogue, with optional per-family native protocol surfaces",
+	"version": "0.2.1",
+	"description": "Sigrun provider plugin: a Bifrost LLM gateway as one dynamic provider — chain models from VK routing rules and/or the upstream catalogue, with optional per-family native protocol surfaces",
 	"type": "module",
 	"engines": {
 		"node": ">=22.19.0"
@@ -25,8 +25,8 @@
 		"prepare": "npm run build"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "1.3.0",
-		"@earendil-works/pi-durable": "1.3.0",
+		"@earendil-works/pi-ai": "1.4.0",
+		"@earendil-works/pi-durable": "1.4.0",
 		"typebox": "1.3.27",
 		"@types/node": "^26.6.4",
 		"typescript": "^7.0.2",