@plurnk/plurnk-providers 1.5.0 → 1.6.1

package/src/Mock.test.ts

@@ -3,6 +3,7 @@ import { strict as assert } from "node:assert";
 import Mock from "./Mock.ts";
 import type { Provider } from "./types.ts";
 import type { MockResponse } from "./Mock.ts";
+import { ProviderError } from "./errors.ts";
 
 const build = (responses: MockResponse[] = [{ assistant: { content: "hi", reasoning: null } }]) =>
     new Mock({ contextWindow: 100000, responses });
@@ -12,6 +13,7 @@ const build = (responses: MockResponse[] = [{ assistant: { content: "hi", reason
 test("Mock: contextWindow and model are stable across reads", () => {
     const m = build();
     assert.equal(m.contextWindow, 100000);
+    assert.equal(m.inputCapacity, null);
     assert.equal(m.contextWindow, 100000);
     assert.equal(m.model, "mock");
     assert.equal(m.model, "mock");
@@ -34,19 +36,23 @@ test("Mock: prompt counting is exact for its declared mock vocabulary", async ()
     });
 });
 
-test("Mock: calculateCost returns its deliberate zero estimate", () => {
-    const m = build();
-    assert.equal(m.calculateCost({ prompt: 100, completion: 20, reasoning: 10, cached: 5, total: 130 }), 0);
-});
-
 // — Transport ({§provider-interface}) —
 
 test("Mock: generate resolves a valid ProviderResponse shape", async () => {
     const m = build([{ assistant: { content: "hello", reasoning: "cot" } }]);
-    const { assistant, assistantRaw } = await m.generate({ messages: [] });
+    const { assistant, assistantRaw, accounting } = await m.generate({ messages: [] });
     assert.equal(assistant.content, "hello");
     assert.equal(assistant.reasoning, "cot");
-    assert.deepEqual(assistant.usage, { prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 });
+    assert.deepEqual(accounting[0]?.usage, {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+    });
+    assert.deepEqual(accounting[0]?.cost, {
+        kind: "estimated",
+        amount: { amount: "0", currency: "USD" },
+        source: "mock provider fixture",
+    });
     assert.equal(assistant.finishReason, "stop");
     assert.equal(assistant.model, "mock");
     assert.equal(assistantRaw, null); // present, defaulted
@@ -57,16 +63,20 @@ test("Mock: generate applies caller-supplied overrides", async () => {
         assistant: {
             content: "x",
             reasoning: null,
-            usage: { prompt: 1, completion: 2, reasoning: 0, cached: 0, total: 3 },
             finishReason: "length",
             model: "mock-xl",
         },
+        usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
         assistantRaw: { wire: true },
     }]);
-    const { assistant, assistantRaw } = await m.generate({ messages: [] });
+    const { assistant, assistantRaw, accounting } = await m.generate({ messages: [] });
     assert.equal(assistant.finishReason, "length");
     assert.equal(assistant.model, "mock-xl");
-    assert.deepEqual(assistant.usage, { prompt: 1, completion: 2, reasoning: 0, cached: 0, total: 3 });
+    assert.deepEqual(accounting[0]?.usage, {
+        inputTokens: 1,
+        outputTokens: 2,
+        totalTokens: 3,
+    });
     assert.deepEqual(assistantRaw, { wire: true });
 });
 
@@ -116,42 +126,71 @@ test("Mock: remaining decrements as responses are consumed", async () => {
     assert.equal(m.remaining, 1);
 });
 
-test("Mock: exhausted queue throws a specific error", async () => {
+test("Mock: exhausted queue throws a ProviderError carrying its settled accounting", async () => {
     const m = build([]);
-    await assert.rejects(() => m.generate({ messages: [] }), /exhausted/);
+    await assert.rejects(
+        () => m.generate({ messages: [] }),
+        (error: unknown) => {
+            assert.ok(error instanceof ProviderError);
+            assert.match(error.message, /exhausted/);
+            assert.deepEqual(error.accounting, [{
+                provider: "provider:mock",
+                model: "mock",
+                outcome: "error",
+                cost: {
+                    kind: "unknown",
+                    reason: "mock provider exhausted before producing a response",
+                },
+            }]);
+            return true;
+        },
+    );
 });
 
 // -- {§provider-generation-envelope} --
 
-test("the reserve getters are on the Provider interface (not just the concrete class)", () => {
-    // Typing against the contract catches a getter-only concrete surface.
-    const prevR = process.env.PLURNK_PROVIDERS_REASONING_RESERVE;
+test("the generation-envelope getters are on the Provider interface", () => {
+    const previous = {
+        output: process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET,
+        reasoning: process.env.PLURNK_PROVIDERS_REASONING_BUDGET,
+    };
     try {
-        process.env.PLURNK_PROVIDERS_REASONING_RESERVE = "10%";
+        process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = "35%";
+        process.env.PLURNK_PROVIDERS_REASONING_BUDGET = "10%";
         const p: Provider = new Mock({ contextWindow: 49152, responses: [] });
-        assert.equal(p.reasoningReserve, 4915); // 10% of 49152, read through the interface type
+        assert.equal(p.outputBudget, 17_203);
+        assert.equal(p.reasoningBudget, 4_915);
+        assert.equal(p.inputCapacity, 31_949);
     } finally {
-        if (prevR === undefined) delete process.env.PLURNK_PROVIDERS_REASONING_RESERVE; else process.env.PLURNK_PROVIDERS_REASONING_RESERVE = prevR;
+        if (previous.output === undefined) delete process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET;
+        else process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = previous.output;
+        if (previous.reasoning === undefined) delete process.env.PLURNK_PROVIDERS_REASONING_BUDGET;
+        else process.env.PLURNK_PROVIDERS_REASONING_BUDGET = previous.reasoning;
     }
 });
 
-test("Mock resolves reserves from PLURNK_PROVIDERS_*_RESERVE against its window (the service partition path)", () => {
-    const prevR = process.env.PLURNK_PROVIDERS_REASONING_RESERVE;
-    const prevC = process.env.PLURNK_PROVIDERS_COMPLETION_RESERVE;
+test("Mock resolves percentage and absolute generation budgets against its window", () => {
+    const previous = {
+        output: process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET,
+        reasoning: process.env.PLURNK_PROVIDERS_REASONING_BUDGET,
+    };
     try {
-        process.env.PLURNK_PROVIDERS_REASONING_RESERVE = "10%";
-        process.env.PLURNK_PROVIDERS_COMPLETION_RESERVE = "8192"; // mixed pct + absolute
+        process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = "35%";
+        process.env.PLURNK_PROVIDERS_REASONING_BUDGET = "8192";
         const m = new Mock({ contextWindow: 49152, responses: [] });
-        assert.equal(m.reasoningReserve, 4915);  // 10% of 49152
-        assert.equal(m.completionReserve, 8192); // absolute stands
+        assert.equal(m.outputBudget, 17_203);
+        assert.equal(m.reasoningBudget, 8_192);
     } finally {
-        if (prevR === undefined) delete process.env.PLURNK_PROVIDERS_REASONING_RESERVE; else process.env.PLURNK_PROVIDERS_REASONING_RESERVE = prevR;
-        if (prevC === undefined) delete process.env.PLURNK_PROVIDERS_COMPLETION_RESERVE; else process.env.PLURNK_PROVIDERS_COMPLETION_RESERVE = prevC;
+        if (previous.output === undefined) delete process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET;
+        else process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = previous.output;
+        if (previous.reasoning === undefined) delete process.env.PLURNK_PROVIDERS_REASONING_BUDGET;
+        else process.env.PLURNK_PROVIDERS_REASONING_BUDGET = previous.reasoning;
     }
 });
 
-test("no reserve env → null (the no-cap path; bare Mocks unaffected)", () => {
+test("no generation-budget env leaves a bare Mock unbounded", () => {
     const m = new Mock({ contextWindow: 49152, responses: [] });
-    assert.equal(m.reasoningReserve, null);
-    assert.equal(m.completionReserve, null);
+    assert.equal(m.outputBudget, null);
+    assert.equal(m.reasoningBudget, null);
+    assert.equal(m.inputCapacity, null);
 });

package/src/Mock.ts

@@ -5,15 +5,15 @@
 // Provider contract. Production providers don't expose the `ops` escape
 // hatch — that's an intg-only convenience.
 
-import type { AuthoritativeCharge, ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderEncryptedReasoningItem, ProviderResponse, ProviderUsage } from "./types.ts";
-import type { ProviderCost } from "@plurnk/plurnk-contracts";
-import { resolveEnvelopeFromEnv } from "./env.ts";
+import type { ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderCost, ProviderEncryptedReasoningItem, ProviderRequestAccounting, ProviderRequestCapacity, ProviderResponse, ProviderUsage } from "./types.ts";
+import { resolveGenerationEnvelopeFromEnv } from "./env.ts";
+import { validateProviderRequestAccounting } from "./accounting.ts";
+import { ProviderError } from "./errors.ts";
+import { assessRequestCapacity, effectiveInputCapacity, effectiveOutputBudget, effectiveReasoningBudget } from "./capacity.ts";
 
 export type MockAssistant = {
     content: string;
     reasoning: string | null;
-    // Partial — omitted fields fall back to DEFAULT_USAGE (e.g. reasoning: 0).
-    usage?: Partial<ProviderUsage>;
     finishReason?: FinishReason;
     model?: string;
     // Provider-normalized encrypted reasoning fixture.
@@ -28,7 +28,9 @@ export type MockAssistant = {
 export type MockResponse = {
     assistant: MockAssistant;
     assistantRaw?: unknown;
-    charge?: AuthoritativeCharge;
+    // Partial — omitted fields fall back to the deliberate zero fixture.
+    usage?: Partial<ProviderUsage>;
+    cost?: ProviderCost;
     grammarEvidence?: GrammarEvidence;
 };
 
@@ -36,34 +38,44 @@ export type MockResponse = {
 export type MockReturnedAssistant = ProviderAssistant & { ops?: unknown[] };
 export type MockReturnedResponse = ProviderResponse & { assistant: MockReturnedAssistant };
 
-const DEFAULT_USAGE: ProviderUsage = { prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 };
+const DEFAULT_USAGE: ProviderUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+};
 type MockGenerateArgs = Omit<Parameters<Provider["generate"]>[0], "workerId"> & { workerId?: string };
 
 export default class Mock implements Provider {
     #contextWindow: number | null;
-    #reasoningReserve: number | null;
-    #completionReserve: number | null;
+    #outputBudget: number | null;
+    #reasoningBudget: number | null;
     #queue: MockResponse[];
 
-    // {§provider-generation-envelope} Reserves resolve the same way a real
-    // provider's do — the tolerant env read (the service's partition/budget
-    // suite sets PLURNK_PROVIDERS_*_RESERVE
-    // and Mock reflects it, resolved against contextWindow). Tolerant, NOT the
-    // fail-hard envelopeFromEnv: Mock is the universal fixture, constructed
-    // without the reserves in most base tests, so absent env → null → the
-    // consumer's no-cap path, and the ~100 `new Mock({ contextWindow, responses })`
-    // sites stay untouched. Mock has no alias identity, so it reads the BARE knobs.
+    // {§provider-generation-envelope} Mock resolves the same generation
+    // envelope as a real provider, but tolerates absent policy because it is
+    // also the universal test fixture. No output budget means its context
+    // window alone cannot determine an input capacity. Mock has no alias
+    // identity, so it reads the bare knobs.
     constructor({ contextWindow, responses }: { contextWindow: number | null; responses: MockResponse[] }) {
         this.#contextWindow = contextWindow;
-        const env = resolveEnvelopeFromEnv(process.env, contextWindow);
-        this.#reasoningReserve = env.reasoningReserve;
-        this.#completionReserve = env.completionReserve;
+        const envelope = resolveGenerationEnvelopeFromEnv(process.env, contextWindow);
+        this.#outputBudget = envelope.outputBudget;
+        this.#reasoningBudget = envelope.reasoningBudget;
         this.#queue = [...responses];
     }
 
     get contextWindow(): number | null { return this.#contextWindow; }
-    get reasoningReserve(): number | null { return this.#reasoningReserve; }
-    get completionReserve(): number | null { return this.#completionReserve; }
+    get maxInputTokens(): number | null { return null; }
+    get maxOutputTokens(): number | null { return null; }
+    get outputBudget(): number | null { return this.#outputBudget; }
+    get reasoningBudget(): number | null { return this.#reasoningBudget; }
+    get inputCapacity(): number | null {
+        return effectiveInputCapacity({
+            contextWindow: this.#contextWindow,
+            maxInputTokens: this.maxInputTokens,
+            outputBudget: this.#outputBudget,
+        });
+    }
     get model(): string { return "mock"; }
 
     // Mock's deliberately simple vocabulary defines each two content code units
@@ -77,22 +89,79 @@ export default class Mock implements Provider {
         };
     }
 
-    // Mock is free.
-    calculateCost(_usage: ProviderUsage): number { return 0; }
-    calculateCharge(_usage: ProviderUsage): Exclude<ProviderCost, { kind: "authoritative" }> { return { kind: "free", source: "mock provider" }; }
+    async assessRequestCapacity(
+        messages: readonly ChatMessage[],
+        maxOutputTokens?: number,
+    ): Promise<ProviderRequestCapacity> {
+        const outputBudget = effectiveOutputBudget({
+            requested: maxOutputTokens,
+            configured: this.#outputBudget,
+            maxOutputTokens: null,
+            contextWindow: this.#contextWindow,
+        });
+        const reasoningBudget = effectiveReasoningBudget({
+            configured: this.#reasoningBudget,
+            outputBudget,
+        });
+        return assessRequestCapacity({
+            contextWindow: this.#contextWindow,
+            maxInputTokens: null,
+            maxOutputTokens: null,
+            outputBudget,
+            reasoningBudget,
+            measurement: await this.countPromptTokens(messages),
+        });
+    }
 
-    async generate({ signal, grammar }: MockGenerateArgs): Promise<MockReturnedResponse> {
+    async generate({ messages, maxOutputTokens, signal, grammar, observeRequest }: MockGenerateArgs): Promise<MockReturnedResponse> {
         // Honor abort before consuming the queue — an aborted call makes no
         // "wire call" and must not exhaust a queued response
         // ({§provider-failure-normalization}).
         signal?.throwIfAborted();
+        const capacity = await this.assessRequestCapacity(messages, maxOutputTokens);
+        if (capacity.decision === "reject") {
+            throw new ProviderError("mock", "capacity_exceeded", "Mock request exceeds its exact input capacity.", {
+                capacity,
+                extensions: { capacityStage: "preflight", capacity },
+            });
+        }
+        const settle = await observeRequest?.({ provider: "provider:mock", model: this.model });
         const next = this.#queue.shift();
-        if (next === undefined) throw new Error("Mock provider exhausted: no more queued responses");
+        if (next === undefined) {
+            const accounting = validateProviderRequestAccounting({
+                provider: "provider:mock",
+                model: this.model,
+                outcome: "error",
+                cost: { kind: "unknown", reason: "mock provider exhausted before producing a response" },
+            });
+            await settle?.(accounting);
+            throw new ProviderError(
+                "mock",
+                "invalid_response",
+                "Mock provider exhausted: no more queued responses",
+                { accounting: [accounting], capacity },
+            );
+        }
         const a = next.assistant;
+        const usage: ProviderUsage = {
+            ...DEFAULT_USAGE,
+            ...next.usage,
+        };
+        const requestAccounting: ProviderRequestAccounting = validateProviderRequestAccounting({
+            provider: "provider:mock",
+            model: a.model ?? this.model,
+            outcome: "response",
+            usage,
+            cost: next.cost ?? {
+                kind: "estimated",
+                amount: { amount: "0", currency: "USD" },
+                source: "mock provider fixture",
+            },
+        });
+        await settle?.(requestAccounting);
         const assistant: MockReturnedAssistant = {
             content: a.content,
             reasoning: a.reasoning,
-            usage: { ...DEFAULT_USAGE, ...a.usage },
             ...(a.reasoningEncrypted !== undefined ? { reasoningEncrypted: a.reasoningEncrypted } : {}),
             finishReason: a.finishReason ?? "stop",
             model: a.model ?? "mock",
@@ -105,7 +174,8 @@ export default class Mock implements Provider {
         return {
             assistant,
             assistantRaw: next.assistantRaw ?? null,
-            ...(next.charge === undefined ? {} : { charge: next.charge }),
+            accounting: [requestAccounting],
+            capacity,
             ...(grammarEvidence !== undefined ? { grammarEvidence } : {}),
         };
     }

package/src/Pool.test.ts

@@ -4,16 +4,43 @@ import Pool from "./Pool.ts";
 import { ProviderError } from "./errors.ts";
 import type { PromptTokenMeasurement, Provider, ProviderResponse } from "./types.ts";
 import { resetEmittedWarnings } from "./warnings.ts";
+import { effectiveInputCapacity } from "./capacity.ts";
 
 test.afterEach(() => { resetEmittedWarnings(); });
 
-const RESP = { assistant: { usage: { prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 2 } }, assistantRaw: null } as unknown as ProviderResponse;
+const RESP: ProviderResponse = {
+    assistant: {
+        content: "ok",
+        reasoning: null,
+        finishReason: "stop",
+        model: "gemma",
+    },
+    assistantRaw: null,
+    accounting: [{
+        provider: "provider:test",
+        model: "gemma",
+        outcome: "response",
+        usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        cost: { kind: "unknown", reason: "test fixture has no cost" },
+    }],
+    capacity: {
+        decision: "admit",
+        contextWindow: 48_000,
+        maxInputTokens: null,
+        maxOutputTokens: null,
+        outputBudget: 12_000,
+        reasoningBudget: null,
+        inputCapacity: 36_000,
+        prompt: { kind: "exact", tokens: 0, source: "test:exact" },
+    },
+};
 
 type FakeOpts = {
     model?: string; window?: number | null; servedModel?: string;
-    constrainsOutput?: boolean; requiresMaxTokens?: boolean;
-    reasoningReserve?: number | null; completionReserve?: number | null;
-    tokenize?: boolean; cost?: number; throws?: Error;
+    constrainsOutput?: boolean; requiresOutputBudget?: boolean;
+    maxInputTokens?: number | null; maxOutputTokens?: number | null;
+    outputBudget?: number | null; reasoningBudget?: number | null;
+    tokenize?: boolean; throws?: Error;
     promptMeasurement?: PromptTokenMeasurement;
 };
 // A fake backend that records which workers it served, and optionally throws.
@@ -22,18 +49,38 @@ const backend = (opts: FakeOpts = {}) => {
     const b: Provider = {
         model: opts.model ?? "gemma",
         contextWindow: opts.window === undefined ? 48000 : opts.window,
+        maxInputTokens: opts.maxInputTokens ?? null,
+        maxOutputTokens: opts.maxOutputTokens ?? null,
+        outputBudget: opts.outputBudget ?? null,
+        reasoningBudget: opts.reasoningBudget ?? null,
+        inputCapacity: effectiveInputCapacity({
+            contextWindow: opts.window === undefined ? 48_000 : opts.window,
+            maxInputTokens: opts.maxInputTokens ?? null,
+            outputBudget: opts.outputBudget ?? null,
+        }),
         ...(opts.servedModel !== undefined ? { servedModel: opts.servedModel } : {}),
         ...(opts.constrainsOutput !== undefined ? { constrainsOutput: opts.constrainsOutput } : {}),
-        ...(opts.requiresMaxTokens !== undefined ? { requiresMaxTokens: opts.requiresMaxTokens } : {}),
-        ...(opts.reasoningReserve !== undefined ? { reasoningReserve: opts.reasoningReserve } : {}),
-        ...(opts.completionReserve !== undefined ? { completionReserve: opts.completionReserve } : {}),
+        ...(opts.requiresOutputBudget !== undefined ? { requiresOutputBudget: opts.requiresOutputBudget } : {}),
         ...(opts.tokenize ? { tokenize: async (t: string) => [t.length] } : {}),
         countPromptTokens: async (messages) => opts.promptMeasurement ?? ({
             kind: "exact",
             tokens: messages.reduce((sum, { content }) => sum + content.length, 0),
             source: "test:exact",
         }),
-        calculateCost: () => opts.cost ?? 0,
+        assessRequestCapacity: async (messages, maxOutputTokens) => ({
+            decision: "admit",
+            contextWindow: opts.window === undefined ? 48_000 : opts.window,
+            maxInputTokens: opts.maxInputTokens ?? null,
+            maxOutputTokens: opts.maxOutputTokens ?? null,
+            outputBudget: maxOutputTokens ?? opts.outputBudget ?? null,
+            reasoningBudget: opts.reasoningBudget ?? null,
+            inputCapacity: null,
+            prompt: opts.promptMeasurement ?? {
+                kind: "exact",
+                tokens: messages.reduce((sum, { content }) => sum + content.length, 0),
+                source: "test:exact",
+            },
+        }),
         generate: async (args: Parameters<Provider["generate"]>[0]): Promise<ProviderResponse> => {
             served.push(args.workerId);
             if (opts.throws !== undefined) throw opts.throws;
@@ -68,20 +115,22 @@ test("Pool: any unknown (null) window makes the pool null - no improvised cap",
     assert.equal(new Pool([backend({ window: 48000 }).b, backend({ window: null }).b]).contextWindow, null);
 });
 
-test("Pool: reserves travel with the floor window", () => {
-    const big = backend({ window: 48000, reasoningReserve: 4800, completionReserve: 12000 }).b;
-    const small = backend({ window: 32000, reasoningReserve: 3200, completionReserve: 8000 }).b;
+test("Pool: physical limits and budgets aggregate to independent safe floors", () => {
+    const big = backend({ window: 48000, maxInputTokens: 40_000, maxOutputTokens: 16_000, outputBudget: 12_000, reasoningBudget: 4_800 }).b;
+    const small = backend({ window: 32000, maxInputTokens: 24_000, maxOutputTokens: 12_000, outputBudget: 8_000, reasoningBudget: 3_200 }).b;
     const p = new Pool([big, small]);
     assert.equal(p.contextWindow, 32000);
-    assert.equal(p.reasoningReserve, 3200);   // the floor backend's, not the larger one's
-    assert.equal(p.completionReserve, 8000);
+    assert.equal(p.maxInputTokens, 24_000);
+    assert.equal(p.maxOutputTokens, 12_000);
+    assert.equal(p.outputBudget, 8_000);
+    assert.equal(p.reasoningBudget, 3_200);
 });
 
-test("Pool: capabilities aggregate conservatively (constrainsOutput all-true, requiresMaxTokens any-true)", () => {
+test("Pool: capabilities aggregate conservatively (constrainsOutput all-true, requiresOutputBudget any-true)", () => {
     assert.equal(new Pool([backend({ constrainsOutput: true }).b, backend({ constrainsOutput: true }).b]).constrainsOutput, true);
     assert.equal(new Pool([backend({ constrainsOutput: true }).b, backend({ constrainsOutput: false }).b]).constrainsOutput, undefined);
-    assert.equal(new Pool([backend({ requiresMaxTokens: false }).b, backend({ requiresMaxTokens: true }).b]).requiresMaxTokens, true);
-    assert.equal(new Pool([backend({}).b]).requiresMaxTokens, undefined);
+    assert.equal(new Pool([backend({ requiresOutputBudget: false }).b, backend({ requiresOutputBudget: true }).b]).requiresOutputBudget, true);
+    assert.equal(new Pool([backend({}).b]).requiresOutputBudget, undefined);
 });
 
 test("Pool: servedModel is the common id, undefined when they differ", () => {
@@ -94,12 +143,11 @@ test("Pool: tokenize is exposed iff every backend has it", () => {
     assert.equal(new Pool([backend({ tokenize: true }).b, backend({ tokenize: false }).b]).tokenize, undefined);
 });
 
-test("Pool: prompt counting + calculateCost delegate to a backend", async () => {
-    const p = new Pool([backend({ cost: 42 }).b]);
+test("Pool: prompt counting delegates conservatively to its backends", async () => {
+    const p = new Pool([backend().b]);
     assert.deepEqual(await p.countPromptTokens([{ role: "user", content: "abcd" }]), {
         kind: "exact", tokens: 4, source: "pool:test:exact",
     });
-    assert.equal(p.calculateCost({ prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 }), 42);
 });
 
 test("Pool: prompt evidence is conservative across every routable backend", async () => {
@@ -118,6 +166,29 @@ test("Pool: prompt evidence is conservative across every routable backend", asyn
         source: "pool:test:a,heuristic:chars2",
         detail: "at least one interchangeable backend has only an estimate: unknown framing",
     });
+
+    const unavailable = backend({ promptMeasurement: {
+        kind: "unavailable", source: "test:none", detail: "counter offline",
+    } }).b;
+    assert.deepEqual(await new Pool([exact, unavailable]).countPromptTokens([]), {
+        kind: "unavailable",
+        source: "pool:test:a,test:none",
+        detail: "at least one interchangeable backend cannot measure the request: counter offline",
+    });
+});
+
+test("Pool: request capacity uses the smallest complete backend envelope", async () => {
+    const prompt = { kind: "exact", tokens: 11, source: "test:exact" } as const;
+    const narrowInput = backend({ window: 100, outputBudget: 90, promptMeasurement: prompt }).b;
+    const narrowContext = backend({ window: 50, outputBudget: 10, promptMeasurement: prompt }).b;
+    const pool = new Pool([narrowInput, narrowContext]);
+
+    assert.equal(pool.inputCapacity, 10);
+    const capacity = await pool.assessRequestCapacity([]);
+    assert.equal(capacity.contextWindow, 50);
+    assert.equal(capacity.outputBudget, 10);
+    assert.equal(capacity.inputCapacity, 10, "independent minima do not synthesize a nonexistent 40-token envelope");
+    assert.equal(capacity.decision, "reject");
 });
 
 // --- dispatch: round-robin + affinity ---