@vincemakes/kiso-runtime 0.29.0 → 0.31.0

package/dist/agent.d.ts

@@ -35,10 +35,22 @@ export interface AgentDefinition {
     readonly hooks?: HookHost;
     /** Direct adapter injection (tests, faux, custom providers). */
     readonly adapter?: Adapter;
-    /** Lazy provider: "anthropic" | "openai-compat" (imports the peer package). */
-    readonly provider?: "anthropic" | "openai-compat";
+    /** Lazy provider: "anthropic" | "openai-compat" | "openai-responses"
+     *  (imports the peer package). */
+    readonly provider?: "anthropic" | "openai-compat" | "openai-responses";
     readonly apiKey?: string;
     readonly baseUrl?: string;
+    /** OR-1: the Responses adapter's ChatGPT target — a thunk that yields
+     *  a FRESH token per request (the CLI's calls the credential store's
+     *  refresh). Its presence is what selects that target; `apiKey`
+     *  selects the first-party one. Ignored by the other providers. */
+    readonly oauth?: () => Promise<{
+        readonly access: string;
+        readonly accountId: string;
+    }>;
+    /** OR-1: the ChatGPT backend's prefix-cache key — the session id, so
+     *  one session's requests share a cache lane. */
+    readonly promptCacheKey?: string;
     /** PH-1c.1: opt-in Anthropic prompt caching (cache_control
      *  breakpoints) — OFF by default; the openai-compat path ignores it
      *  (that dialect's caching is server-automatic). Type-only additive. */
@@ -83,8 +95,13 @@ export declare function createAgent(definition: AgentDefinition): AgentRuntime;
  * adapter each call; the caller (session.setAdapter) decides when it
  * takes effect.
  */
-export declare function buildAdapter(provider: "anthropic" | "openai-compat", opts?: {
+export declare function buildAdapter(provider: "anthropic" | "openai-compat" | "openai-responses", opts?: {
     readonly apiKey?: string;
     readonly baseUrl?: string;
     readonly promptCaching?: boolean;
+    readonly oauth?: () => Promise<{
+        readonly access: string;
+        readonly accountId: string;
+    }>;
+    readonly promptCacheKey?: string;
 }): Promise<Adapter>;

package/dist/agent.js

@@ -121,6 +121,9 @@ export class AgentRuntime {
         const config = {
             model: restored?.model ?? this.#definition.model,
             ...(this.#definition.provider !== undefined ? { provider: this.#definition.provider } : {}),
+            // OR-1: the endpoint rides with the provider — the cost path and
+            // the window lookup key on (model, endpoint), never on the id alone.
+            ...(this.#definition.baseUrl !== undefined ? { baseUrl: this.#definition.baseUrl } : {}),
             ...((restored !== null ? restored.scope : startupScope) !== undefined
                 ? { continuationScope: (restored !== null ? restored.scope : startupScope) }
                 : {}),
@@ -217,7 +220,25 @@ async function resolveAdapter(definition) {
                     : {}),
             });
         }
+        case "openai-responses": {
+            const { createOpenAIResponsesProvider } = await import("@vincemakes/kiso-provider-openai-responses");
+            // MG-1 (A5): the adapter's replay identity is the SAME one the
+            // run's stamping scope uses, so emit and replay agree — the
+            // openai-compat case's rule, one dialect over.
+            const scope = resolveContinuationScope("openai-responses", "", definition.baseUrl);
+            // The adapter picks its TARGET from these options — an `oauth`
+            // thunk is the ChatGPT backend, an `apiKey` is the first-party
+            // API — so no separate switch exists to disagree with the
+            // credential the CLI resolved.
+            return createOpenAIResponsesProvider({
+                ...(scope !== undefined ? { scope: { providerId: scope.providerId } } : {}),
+                ...(definition.apiKey !== undefined ? { apiKey: definition.apiKey } : {}),
+                ...(definition.oauth !== undefined ? { oauth: definition.oauth } : {}),
+                ...(definition.baseUrl !== undefined ? { baseUrl: definition.baseUrl } : {}),
+                ...(definition.promptCacheKey !== undefined ? { promptCacheKey: definition.promptCacheKey } : {}),
+            });
+        }
         default:
-            throw new Error("createAgent: pass an `adapter` or a `provider` (\"anthropic\" | \"openai-compat\")");
+            throw new Error("createAgent: pass an `adapter` or a `provider` (\"anthropic\" | \"openai-compat\" | \"openai-responses\")");
     }
 }

package/dist/provider/manifest.d.ts

@@ -25,11 +25,14 @@ export interface ProviderManifest {
     readonly apiIds: readonly string[];
     readonly defaultEndpoint?: string;
 }
-/** The five built-in identities. `custom` is the honest bucket for any
+/** The six built-in identities. `custom` is the honest bucket for any
  *  OpenAI-compatible endpoint the origin table does not recognize —
- *  capabilities default to UNKNOWN there, never borrowed from OpenAI. */
+ *  capabilities default to UNKNOWN there, never borrowed from OpenAI.
+ *  `chatgpt` is a PROVIDER, not a dialect: the subscription backend
+ *  serves the Responses dialect and nothing else, and it authenticates
+ *  by OAuth only — there is no API key that reaches it. */
 export declare const BUILTIN_MANIFESTS: readonly ProviderManifest[];
 /** The run's continuation scope, resolved from the live binding. An
  *  undefined provider (a directly injected SDK/faux adapter) is an
  *  UNSCOPED run: the kernel strips adapter-emitted continuation. */
-export declare function resolveContinuationScope(provider: "anthropic" | "openai-compat" | undefined, model: string, baseUrl?: string): ContinuationScope | undefined;
+export declare function resolveContinuationScope(provider: "anthropic" | "openai-compat" | "openai-responses" | undefined, model: string, baseUrl?: string): ContinuationScope | undefined;

package/dist/provider/manifest.js

@@ -11,12 +11,16 @@
  *
  * Lives under runtime/internal — the curated root surface does not move.
  */
-/** The five built-in identities. `custom` is the honest bucket for any
+/** The six built-in identities. `custom` is the honest bucket for any
  *  OpenAI-compatible endpoint the origin table does not recognize —
- *  capabilities default to UNKNOWN there, never borrowed from OpenAI. */
+ *  capabilities default to UNKNOWN there, never borrowed from OpenAI.
+ *  `chatgpt` is a PROVIDER, not a dialect: the subscription backend
+ *  serves the Responses dialect and nothing else, and it authenticates
+ *  by OAuth only — there is no API key that reaches it. */
 export const BUILTIN_MANIFESTS = [
     { id: "anthropic", revision: "2026-08-26.1", authMethods: ["api-key", "none"], apiIds: ["anthropic-messages"], defaultEndpoint: "https://api.anthropic.com" },
     { id: "openai", revision: "2026-08-26.1", authMethods: ["api-key", "none"], apiIds: ["openai-chat", "openai-responses"], defaultEndpoint: "https://api.openai.com" },
+    { id: "chatgpt", revision: "2026-09-08.1", authMethods: ["oauth"], apiIds: ["openai-responses"], defaultEndpoint: "https://chatgpt.com/backend-api" },
     { id: "deepseek", revision: "2026-08-26.1", authMethods: ["api-key", "none"], apiIds: ["openai-chat"], defaultEndpoint: "https://api.deepseek.com" },
     { id: "zai", revision: "2026-08-26.1", authMethods: ["api-key", "none"], apiIds: ["openai-chat"], defaultEndpoint: "https://api.z.ai" },
     { id: "custom", revision: "2026-08-26.1", authMethods: ["api-key", "none"], apiIds: ["openai-chat"] },
@@ -31,6 +35,21 @@ const KNOWN_ORIGINS = {
     "https://open.bigmodel.cn": "zai",
     "https://api.openai.com": "openai",
 };
+/** The ChatGPT backend's origin. Deliberately NOT in KNOWN_ORIGINS: that
+ *  table resolves openai-CHAT profiles, and the subscription backend does
+ *  not speak that dialect — a compat profile pointed at it is broken, not
+ *  a `chatgpt` binding. */
+const CHATGPT_ORIGIN = "https://chatgpt.com";
+function isChatgptOrigin(baseUrl) {
+    if (baseUrl === undefined)
+        return false;
+    try {
+        return new URL(baseUrl).origin === CHATGPT_ORIGIN;
+    }
+    catch {
+        return false;
+    }
+}
 /** The run's continuation scope, resolved from the live binding. An
  *  undefined provider (a directly injected SDK/faux adapter) is an
  *  UNSCOPED run: the kernel strips adapter-emitted continuation. */
@@ -40,6 +59,14 @@ export function resolveContinuationScope(provider, model, baseUrl) {
     if (provider === "anthropic") {
         return { providerId: "anthropic", apiId: "anthropic-messages", modelId: model };
     }
+    if (provider === "openai-responses") {
+        // Two identities serve this dialect and no others, so there is no
+        // `custom` bucket here: the ChatGPT origin, or OpenAI. This is the
+        // ONLY place the rule lives — the adapter is HANDED the result
+        // (agent.ts's openai-responses case) rather than re-deriving it,
+        // so the stamping side and the replay side cannot disagree.
+        return { providerId: isChatgptOrigin(baseUrl) ? "chatgpt" : "openai", apiId: "openai-responses", modelId: model };
+    }
     if (baseUrl === undefined) {
         return { providerId: "openai", apiId: "openai-chat", modelId: model };
     }

package/dist/provider/metadata.d.ts

@@ -42,7 +42,9 @@ export interface ModelCapabilities {
  *  effort affects whole responses with or without explicit thinking, and
  *  some model/effort combinations forbid thinking-disabled. */
 export type ThinkingMode = "default" | "adaptive" | "enabled" | "disabled";
-export type ReasoningEffort = "default" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** `none` is the OpenAI Responses dialect's zero-reasoning level — a NATIVE
+ *  value a request carries, distinct from "default" (no field sent). */
+export type ReasoningEffort = "default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export interface ReasoningSetting {
     readonly thinking: ThinkingMode;
     readonly effort: ReasoningEffort;

package/dist/provider/metadata.js

@@ -97,6 +97,47 @@ function anthropicLine() {
         row("claude-haiku-4-5", haiku, haikuPricing),
     ];
 }
+const OPENAI_MODELS_ASOF = "2026-09-08";
+/** the vendor CLI's per-model presets, pinned (the levels it offers a
+ *  subscription; a first-party model page says nothing about that backend). */
+const CHATGPT_PRESETS_SOURCE = "https://github.com/openai/codex/blob/37f4bb94c9f4e180535a12e3f2c2f93f4a773df0/codex-rs/models-manager/models.json";
+const RESPONSES_WIRE = "reasoning.effort";
+/** A first-party Responses row: the model page is the source for the
+ *  levels, the window, the output cap and the price alike (read the same
+ *  day). The adapter asks for no reasoning summaries (encrypted items
+ *  only), so no thinking stream is emitted. */
+const openaiRow = (model, effortDefault, rate, page) => ({
+    model,
+    providerId: "openai",
+    endpoint: "https://api.openai.com",
+    capabilities: { contextWindow: 1_050_000, maxOutputTokens: 128_000, promptCaching: "automatic", reasoning: {
+            emitsThinkingStream: false,
+            thinking: null,
+            effort: { levels: ["none", "low", "medium", "high", "xhigh"], default: effortDefault, wire: RESPONSES_WIRE },
+            asOf: OPENAI_MODELS_ASOF,
+            source: page,
+        }, inputModalities: null },
+    capabilitiesAsOf: OPENAI_MODELS_ASOF,
+    capabilitiesSource: page,
+    pricing: { ...rate, cacheWritePerM: 0, asOf: OPENAI_MODELS_ASOF, source: page },
+});
+/** The subscription backend's row for the same id: the presets' four
+ *  levels (no `none`), the presets' context window, no price. */
+const chatgptRow = (model) => ({
+    model,
+    providerId: "chatgpt",
+    endpoint: "https://chatgpt.com",
+    capabilities: { contextWindow: 272_000, maxOutputTokens: null, promptCaching: null, reasoning: {
+            emitsThinkingStream: false,
+            thinking: null,
+            effort: { levels: ["low", "medium", "high", "xhigh"], default: "medium", wire: RESPONSES_WIRE },
+            asOf: OPENAI_MODELS_ASOF,
+            source: CHATGPT_PRESETS_SOURCE,
+        }, inputModalities: null },
+    capabilitiesAsOf: OPENAI_MODELS_ASOF,
+    capabilitiesSource: CHATGPT_PRESETS_SOURCE,
+    pricing: null,
+});
 /** The v1 table. Nulls outnumber numbers ON PURPOSE: only values with a
  *  named source enter; everything else waits for one. */
 const ENTRIES = [
@@ -174,6 +215,23 @@ const ENTRIES = [
         capabilities: { contextWindow: 128_000, maxOutputTokens: null, promptCaching: "automatic", reasoning: { emitsThinkingStream: false, thinking: null, effort: null, asOf: null, source: null }, inputModalities: null },
         pricing: null,
     },
+    // OR-1 (2026-09-08): the Responses-dialect rows. The SAME model id gets
+    // TWO rows because it answers differently at each endpoint: the
+    // first-party API documents `none` and a per-token price; the
+    // subscription backend is paid by the subscription (pricing: null — a
+    // first-party rate must never be shown as if it were the bill) and
+    // offers the levels the vendor's own CLI presets list, pinned to a
+    // commit. The first-party row is listed FIRST on purpose: an
+    // endpoint-less lookup (a caller with no baseUrl — a direct-write
+    // profile, the faux path) resolves to it, and its levels are a
+    // superset of the subscription row's. The run-side resolver passes
+    // the binding's endpoint (the second OR-1 review), so this ordering
+    // is the endpoint-less FALLBACK, not the guard that keeps a
+    // subscription run from carrying a level its backend lacks.
+    openaiRow("gpt-5.5", "medium", { inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 }, "https://developers.openai.com/api/docs/models/gpt-5.5"),
+    openaiRow("gpt-5.4", "none", { inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 }, "https://developers.openai.com/api/docs/models/gpt-5.4"),
+    chatgptRow("gpt-5.5"),
+    chatgptRow("gpt-5.4"),
 ];
 /**
  * Look a model up. `endpoint` narrows: an entry WITH an endpoint only

package/dist/run.js

@@ -100,6 +100,8 @@ export class Run {
                 runId: this.runId,
                 provider: this.#config.provider ?? "adapter",
                 model: this.#config.model,
+                // OR-1: the binding's endpoint — the record's price keys on it.
+                ...(this.#config.baseUrl !== undefined ? { endpoint: this.#config.baseUrl } : {}),
                 adapterVersion: runtimeVersion(),
                 log: log.all,
                 rentParts,
@@ -135,7 +137,12 @@ export class Run {
                 // XP-1: native-only resolution — an unsupported recorded
                 // setting REFUSES the run with the reason (no silent
                 // downgrade); default/default adds nothing (byte anchor).
-                ...(this.#config.reasoning !== undefined ? resolveReasoningOrThrow(this.#config.model, this.#config.reasoning) : {}),
+                // OR-1: resolved against the binding's ENDPOINT — the same
+                // model id offers different levels at the first-party API
+                // and at the subscription backend, and the CLI's /model
+                // pre-check is not the runtime's guarantee (a direct
+                // setModelBinding or a recorded profile reaches here without it).
+                ...(this.#config.reasoning !== undefined ? resolveReasoningOrThrow(this.#config.model, this.#config.reasoning, this.#config.baseUrl) : {}),
                 // E1: the composed approval chain — the extensions'
                 // policies composed into ONE gate (deny > allow > ask).
                 ...(approvalChain !== undefined ? { approvalPolicy: approvalChain } : {}),
@@ -787,8 +794,8 @@ export class Run {
 }
 /** XP-1: the run-side half of "no silent downgrade" — a setting the
  *  matrix refuses becomes an actionable failure, never a quiet default. */
-function resolveReasoningOrThrow(model, setting) {
-    const r = resolveReasoning(model, setting);
+function resolveReasoningOrThrow(model, setting, endpoint) {
+    const r = resolveReasoning(model, setting, endpoint);
     if (!r.ok)
         throw new Error(`the session's recorded reasoning setting cannot run here: ${r.reason}`);
     return Object.keys(r.wire).length > 0 ? { reasoning: r.wire } : {};

package/dist/session.d.ts

@@ -130,7 +130,11 @@ export declare class AgentSession {
     setModelBinding(binding: {
         readonly adapter: Adapter;
         readonly model: string;
-        readonly provider?: "anthropic" | "openai-compat";
+        readonly provider?: "anthropic" | "openai-compat" | "openai-responses";
+        /** OR-1: the endpoint moves with the adapter too — the cost path
+         *  and the window lookup key on (model, endpoint); absent = an
+         *  endpoint-less lookup (the first row for the id). */
+        readonly baseUrl?: string;
         /** MG-1 (A5): the run's continuation scope — moves atomically with
          *  the adapter (absent = unscoped: the kernel strips envelopes). */
         readonly scope?: ContinuationScope;
@@ -138,11 +142,15 @@ export declare class AgentSession {
          *  fresh defaults (a new binding never inherits stale effort). */
         readonly reasoning?: ReasoningSetting;
     }): void;
-    /** E2: the adapter identity ("anthropic" | "openai-compat") — the route
+    /** E2: the adapter identity (anthropic / openai-compat / openai-responses) — the route
      *  key the canonical consumer (CLI usage, the trace block) keys on. The
      *  per-run tracer reads the SAME live binding; one source, one
      *  route — the CLI and the trace can never disagree. */
-    get provider(): "anthropic" | "openai-compat" | undefined;
+    get provider(): "anthropic" | "openai-compat" | "openai-responses" | undefined;
+    /** OR-1: the live binding's endpoint — what the CLI hands the cost
+     *  path next to `provider` and `model`, so the status row's dollar
+     *  figure and the ledger's can never key on different registry rows. */
+    get baseUrl(): string | undefined;
     /** XP-1: the model that will answer the NEXT request — the live
      *  binding, restored from the durable profile on open. The status row
      *  reads THIS, so the row and the request can never disagree. */
@@ -376,9 +384,15 @@ export interface ContextPolicy {
 }
 export interface SessionConfig {
     readonly model: string;
-    /** E1: the adapter identity ("anthropic" | "openai-compat") — trace
+    /** E1: the adapter identity (anthropic / openai-compat / openai-responses) — trace
      *  provenance, additive (S1 surface untouched: type-only, optional). */
-    readonly provider?: "anthropic" | "openai-compat";
+    readonly provider?: "anthropic" | "openai-compat" | "openai-responses";
+    /** OR-1: the adapter's endpoint. The registry row for one model id can
+     *  differ per endpoint (gpt-5.5 is priced at the first-party API and
+     *  unpriced at the ChatGPT backend), so the cost path and the window
+     *  lookup key on (model, endpoint). Travels with the live binding,
+     *  exactly as `provider` does. Type-only, optional. */
+    readonly baseUrl?: string;
     /** MG-1 (A5): the run's continuation scope — the kernel stamps it on
      *  committed envelopes; absent = unscoped (envelopes stripped). */
     readonly continuationScope?: import("@vincemakes/kiso-core").ContinuationScope;

package/dist/session.js

@@ -85,6 +85,8 @@ export class AgentSession {
     // setAdapter always had).
     #model;
     #provider;
+    // OR-1: the fourth passenger — the endpoint moves with the adapter too.
+    #baseUrl;
     // MG-1 (A5): travels WITH the adapter, same next-turn semantics.
     #continuationScope;
     // XP-1: the selected axes; resolved per request (next-turn semantics).
@@ -140,6 +142,7 @@ export class AgentSession {
         this.#config = composedHooks === undefined ? config : { ...config, hooks: composedHooks };
         this.#model = config.model;
         this.#provider = config.provider;
+        this.#baseUrl = config.baseUrl;
         this.#continuationScope = config.continuationScope;
         this.#reasoning = config.reasoning ?? { thinking: "default", effort: "default" };
         this.#profilePending = config.profilePending === true;
@@ -149,11 +152,12 @@ export class AgentSession {
      *  fresh per call so an in-flight run keeps the config it started with
      *  — the same boundary setAdapter has always drawn. */
     #effectiveConfig() {
-        const { provider: _startup, continuationScope: _startupScope, ...rest } = this.#config;
+        const { provider: _startup, baseUrl: _startupUrl, continuationScope: _startupScope, ...rest } = this.#config;
         return {
             ...rest,
             model: this.#model,
             ...(this.#provider !== undefined ? { provider: this.#provider } : {}),
+            ...(this.#baseUrl !== undefined ? { baseUrl: this.#baseUrl } : {}),
             ...(this.#continuationScope !== undefined ? { continuationScope: this.#continuationScope } : {}),
             reasoning: this.#reasoning,
         };
@@ -216,19 +220,26 @@ export class AgentSession {
         this.#adapter = binding.adapter;
         this.#model = binding.model;
         this.#provider = binding.provider;
+        this.#baseUrl = binding.baseUrl;
         this.#continuationScope = binding.scope;
         this.#reasoning = binding.reasoning ?? { thinking: "default", effort: "default" };
         // XP-1: an explicit selection is DURABLE — the setting survives
         // /resume because a revision records it now, not at some later flush.
         this.#recordProfile();
     }
-    /** E2: the adapter identity ("anthropic" | "openai-compat") — the route
+    /** E2: the adapter identity (anthropic / openai-compat / openai-responses) — the route
      *  key the canonical consumer (CLI usage, the trace block) keys on. The
      *  per-run tracer reads the SAME live binding; one source, one
      *  route — the CLI and the trace can never disagree. */
     get provider() {
         return this.#provider;
     }
+    /** OR-1: the live binding's endpoint — what the CLI hands the cost
+     *  path next to `provider` and `model`, so the status row's dollar
+     *  figure and the ledger's can never key on different registry rows. */
+    get baseUrl() {
+        return this.#baseUrl;
+    }
     /** XP-1: the model that will answer the NEXT request — the live
      *  binding, restored from the durable profile on open. The status row
      *  reads THIS, so the row and the request can never disagree. */
@@ -314,6 +325,8 @@ export class AgentSession {
             runId,
             provider: this.#provider ?? "adapter",
             model: this.#model,
+            // OR-1: the side query is priced by the same live endpoint as a run.
+            ...(this.#baseUrl !== undefined ? { endpoint: this.#baseUrl } : {}),
             adapterVersion: runtimeVersion(),
             purpose: options.purpose,
             // the manifest's seqRange pointers derive from the log, and a side
@@ -418,6 +431,14 @@ export class AgentSession {
         });
         let summary;
         let usage = null;
+        // OR-1 (the second review): the summary is priced by the binding that
+        // MADE the request. A /model switch during this call — the session's
+        // longest single request — moves #model/#baseUrl/#provider under it;
+        // reading them after the await priced a subscription summary at the
+        // first-party rate. ONE snapshot serves the request and the ledger
+        // line, the PH-F8 law (adapter, model, provider move together)
+        // applied to the one off-loop call.
+        const binding = { adapter: this.#adapter, model: this.#model, baseUrl: this.#baseUrl, provider: this.#provider };
         if (options.drop === true) {
             // E6 — the crux drop arm: mechanical, no model call, the fixed
             // placeholder replaces the covered range (experiment-only).
@@ -425,8 +446,8 @@ export class AgentSession {
         }
         else {
             const call = await summarizeConversation({
-                adapter: this.#adapter,
-                model: this.#model,
+                adapter: binding.adapter,
+                model: binding.model,
                 // E6 (a): ONE serialized user message — the DSML bug's
                 // raw-message array is structurally dead on this path.
                 messages: [{ role: "user", content: serializedInput }],
@@ -460,7 +481,7 @@ export class AgentSession {
         // a degraded ledger costs one stderr line, never the summary.
         if (usage !== null) {
             try {
-                const canonical = canonicalizeUsageForModel(this.#model, undefined, this.#provider ?? "adapter", usage);
+                const canonical = canonicalizeUsageForModel(binding.model, binding.baseUrl, binding.provider ?? "adapter", usage);
                 const line = JSON.stringify({ kind: "summary", canonical }) + "\n";
                 mkdirSync(join(this.#store.root, "traces"), { recursive: true });
                 appendFileSync(join(this.#store.root, "traces", `${this.id}.jsonl`), line);

package/dist/trace/guard.d.ts

@@ -29,6 +29,9 @@ export interface RequestTracerDeps {
     runId: string;
     provider: string;
     model: string;
+    /** OR-1: the adapter's endpoint — the registry row (and so the price)
+     *  for one model id can differ per endpoint; absent = endpoint-less. */
+    endpoint?: string;
     /** The adapter contract's implementation version (the runtime's own),
      *  resolved once at tracer init; null on failure (soft-fail). */
     adapterVersion?: string | null;

package/dist/trace/guard.js

@@ -33,6 +33,7 @@ export class RequestTracer {
     #writer;
     #log;
     #provider;
+    #endpoint;
     #runId;
     #adapterVersion;
     #rentParts;
@@ -43,6 +44,7 @@ export class RequestTracer {
         this.#writer = new TraceWriter({ root: deps.root, sessionId: deps.sessionId });
         this.#log = deps.log;
         this.#provider = deps.provider;
+        this.#endpoint = deps.endpoint;
         this.#runId = deps.runId;
         this.#adapterVersion = deps.adapterVersion ?? null;
         this.#rentParts = deps.rentParts;
@@ -208,7 +210,10 @@ export class RequestTracer {
         // MODEL via the metadata registry (route-keyed pricing priced an
         // Anthropic run at DeepSeek's rates); the convention still keys on
         // the route. An unpriced model costs null — never a fallback rate.
-        record.canonical = canonicalizeUsageForModel(record.model, undefined, this.#provider, {
+        // OR-1: and on the binding's ENDPOINT — the same id is priced at the
+        // first-party API and unpriced at the subscription backend; an
+        // endpoint-less lookup here priced a subscription run at $5/$30.
+        record.canonical = canonicalizeUsageForModel(record.model, this.#endpoint, this.#provider, {
             inputTokens: p.inputTokens,
             outputTokens: p.outputTokens,
             cacheRead: p.cacheRead,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.29.0",
+	"version": "0.31.0",
 	"description": "kiso runtime — durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
 	"type": "module",
 	"license": "MIT",
@@ -25,11 +25,12 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.29.0"
+		"@vincemakes/kiso-core": "0.31.0"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.29.0",
-		"@vincemakes/kiso-provider-openai": "0.29.0"
+		"@vincemakes/kiso-provider-anthropic": "0.31.0",
+		"@vincemakes/kiso-provider-openai": "0.31.0",
+		"@vincemakes/kiso-provider-openai-responses": "0.31.0"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -37,10 +38,13 @@
 		},
 		"@vincemakes/kiso-provider-openai": {
 			"optional": true
+		},
+		"@vincemakes/kiso-provider-openai-responses": {
+			"optional": true
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.29.0",
+		"@vincemakes/kiso-evals": "0.31.0",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"