llm-cli-gateway 2.16.0 → 2.17.1

package/.agents/skills/least-cost-routing/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: least-cost-routing
+description: Route a model-agnostic request to the cheapest capable (provider, model) via route_request, subject to a quality-tier floor and a hard budget cap. Use when you do not care WHICH model runs a task, only that it is cheap enough and good enough.
+metadata:
+  author: verivus-oss
+  version: "1.0"
+---
+
+# Least-cost routing (route_request)
+
+`route_request` (sync) and `route_request_async` (async) pick the **cheapest
+eligible `(provider, model)`** candidate that meets your constraints, then
+dispatch it through the normal provider path. They are **dormant by default**:
+registered only when `[least_cost].enabled = true` in
+`~/.llm-cli-gateway/config.toml`. If the tools are absent, routing is off; use a
+specific provider tool instead.
+
+## When to use this vs a named provider tool
+
+- Use `route_request` when the task is model-agnostic (summarize, answer,
+  classify, rewrite) and you want the cheapest model that clears a quality floor.
+- Use `claude_request` / `codex_request` / etc. when you need a SPECIFIC model or
+  provider, a provider-specific flag, session resume, or a worktree. In phase_1
+  `route_request` is fresh one-shot only (no `sessionId` / `workspace` /
+  `worktree`).
+
+## Inputs
+
+- `prompt` (or `promptParts`): the request. Exactly one.
+- `minTier`: `economy | standard | frontier` (default `standard`). A hard floor,
+  never downgraded to save money.
+- `maxCostUsd`: per-request budget cap. Over-budget fails closed.
+- `expectedOutputTokens` / `maxOutputTokens`: tune the ranking and the
+  conservative budget bound.
+- `requiredCapabilities`: `{ images?, attachments?, toolCalling?, jsonSchema?,
+  outputFormat?, effort? }`. A candidate missing a required capability is
+  excluded.
+- `candidates`: an explicit `(provider, model)[]` to restrict the pool (also
+  whitelists otherwise-untiered / maintain-only candidates like cursor/devin).
+- `allowUnpriced` + `budgetWaiver`: BOTH are required to admit an unpriced
+  (`source: "unknown"`) candidate. An unpriced candidate always ranks strictly
+  last and cannot win over any priced candidate.
+- `fallback`: a `(provider, model)` used ONLY when the eligible pool is empty;
+  bypasses cost ranking but still passes eligibility and (unless `budgetWaiver`)
+  the budget gate.
+
+## Reading the result
+
+Every routed response carries a `routing` block in `structuredContent.routing`,
+and a one-line `[routing] chosen=... est=$... (basis, confidence) considered=N
+reroutes=M` banner prepended to the text. Fields: `chosen`, `tier`,
+`estCostUsd`, `costBasis` (`provider-reported | derived-from-tokens |
+pre-flight-estimate`), `confidence`, `nearTie`, `estInputTokens`,
+`estOutputTokens`, `priceAsOf`, `priceSource`, `consideredCount`,
+`rejected: [{candidate, reason}]`, `reroutes`, and (on failure) `error`.
+
+`estCostUsd` is always an ESTIMATE labelled with its inputs, never a billed cost.
+
+## Failure semantics (fail closed)
+
+- Over budget: `routing.error = "BudgetExceeded"`, `isError: true`. Raise
+  `maxCostUsd` rather than expecting a silent downgrade.
+- No eligible candidate: `routing.error = "NoEligibleCandidate"` with the
+  per-candidate rejection reasons (auth / breaker / capacity / capability / tier
+  / price / budget). Loosen `minTier`, add `candidates`, or set
+  `allowUnpriced` + `budgetWaiver`.
+- Transient dispatch failure (breaker trip, timeout): LCR re-selects over the
+  remaining pool up to `[least_cost].max_reroutes`. Non-transient failures drop
+  the candidate and continue.
+
+## Observability (phase_2)
+
+When routing is enabled, three read-only surfaces expose how it is behaving
+(all economics-only, no prompts/secrets/principal):
+
+- `routing://decisions` (MCP resource): the recent routed decisions, each with
+  `provider`/`model`, `estCostUsd`, `costBasis`, `confidence`, `reason`,
+  `considered`, `reroutes`, `at`.
+- `routing://priors` (MCP resource): the learned per-`(provider,model)`
+  output-token priors (median/p90/samples), the per-`(content-type,family)`
+  input calibration `k` + sample count + confidence, and `priceAsOf`. Priors are
+  anonymized model-level economics; `priors_scope` (`global | principal | off`)
+  scopes the learning (or disables it).
+- `llm_process_health` gains a `leastCost` block: per-provider telemetry tier
+  (T1..T4) and per-candidate eligibility (priced? / authed? / breaker? / tier?).
+- `doctor --json` gains a `least_cost` block: pricing `asOf` + staleness,
+  per-provider telemetry tier, per-candidate eligibility, untiered models, and
+  per-`(content-type,family)` calibration quality (`k`/samples/confidence).
+
+API-provider models are priced from a published catalog (`prefer_catalog_price`
+picks catalog over the CLI table when both resolve).
+
+## Cheapest-reviewer selection (phase_3)
+
+`validate_with_models`, `red_team_review`, `consensus_check`, `second_opinion`,
+and `ask_model` accept an OPT-IN `select: "cheapest" | "cheapest_per_tier"`. When
+omitted, the explicit `models`/`model` list is used verbatim (default unchanged).
+When set, the reviewer target list is filled via the LCR selector:
+`cheapest` picks the single cheapest eligible provider; `cheapest_per_tier` picks
+the cheapest provider in each quality tier (economy/standard/frontier). It fails
+closed (no jobs started) when `[least_cost].enabled` is false or nothing is
+eligible.
+
+## Config (operator, `~/.llm-cli-gateway/config.toml`)
+
+```toml
+[least_cost]
+enabled = true                 # nothing routes until this is true
+min_tier = "standard"
+max_cost_usd = 0.50
+allow_unpriced = false
+max_reroutes = 2
+
+[least_cost.tiers]             # (provider:family) -> tier; ships with defaults
+"claude:claude-opus" = "frontier"
+
+[least_cost.candidates]
+allow = []                     # empty = all eligible
+deny = []
+```
+
+See `docs/least-cost-routing-contract.md` for the frozen decisions and
+invariants.

package/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to the llm-cli-gateway project.
 
 ## [Unreleased]
 
+## [2.17.1] - 2026-07-13
+
+### Fixed
+
+- **Upstream CLI contract refresh.** Updated installed-provider contracts for
+  Claude, Codex, Antigravity, Grok, Mistral Vibe, Devin, and Cursor Agent.
+  Vibe now emits its supported `--disabled-tools` denylist control instead of
+  silently ignoring `disallowedTools`.
+
+## [2.17.0] - 2026-07-13
+
+### Added
+
+- **Least-cost routing.** `route_request` and `route_request_async` select the
+  cheapest eligible provider and model within a quality floor, budget cap, and
+  current capacity constraints. The router now exposes pricing, estimates,
+  route decisions, health, and learned cost priors through `routing://`
+  resources.
+- **Cheapest eligible validation.** `validate_with_models` can now select a
+  least-cost eligible model rather than requiring callers to name one.
+- **Supply-chain release guards.** Dependency drift, tag-along packages,
+  unexpected install scripts, licenses, and policy changes are checked before
+  release, with fail-closed protection for uncertain findings.
+
+### Fixed
+
+- **Durable Postgres job-store recovery.** Replaced temporary-file worker
+  result handoff with in-process message channels, preserving failure detail
+  and avoiding host `/tmp` inode exhaustion. A failed bridge now retires and
+  recreates its worker safely, and durable admission recovers only after a
+  successful re-registration.
+- **Async availability reporting and lifecycle.** Readiness and process health
+  now reflect durable-admission state, configured-store startup failures exit
+  for supervised recovery, and shutdown reliably closes the job store.
+- **Release and test gates.** The lint command now checks the actual source
+  tree, and Postgres integration tests work with either Docker or Podman.
+
 ## [2.16.0] - 2026-07-10
 
 ### Added

package/README.md

@@ -97,7 +97,7 @@ The next documentation focus is provider-specific skill and DAG-TOML pairs for e
 - CI runs build, lint, format, tests, package checks, and npm audit.
 - Security CI runs actionlint, zizmor, shellcheck, typos, osv-scanner, gitleaks, and lychee.
 - GitHub release installer artifacts are checksummed and signed with Sigstore keyless signing.
-- npm releases use a generated prod-only shrinkwrap and release security audit; the publish token is fetched at runtime from Azure Key Vault through GitHub OIDC to Entra.
+- npm releases use a generated prod-only shrinkwrap and release security audit; GitHub Actions Trusted Publishing exchanges the job's OIDC identity for short-lived npm publish credentials.
 - The npm package intentionally ships a generated, prod-only `npm-shrinkwrap.json` so registry installs resolve the audited release tree. Release gates regenerate it from `package-lock.json`, compare for parity, and run a registry-fidelity consumer install before publishing.
 - Socket behavioural alerts are documented in [`socket.yml`](./socket.yml) and under "Security Considerations" below. `shellAccess` and `shrinkwrap` are reviewed package capabilities/configuration for this CLI appliance, not hidden install behaviour.
 
@@ -370,12 +370,12 @@ Vibe-specific notes:
   `default | plan | accept-edits | auto-approve`; Vibe also accepts install-gated
   builtins (e.g. `lean`) and custom agents from `~/.vibe/agents`, so any name is
   passed through and Vibe validates availability. The gateway's
-  programmatic-mode default is `auto-approve`; pick a stricter mode
-  explicitly if you need approval gates.
-- **`allowedTools` is allow-list only** — the gateway emits one
-  `--enabled-tools <tool>` flag per entry. `disallowedTools` is accepted in
-  the schema for caller-side parity but is silently ignored at the CLI
-  boundary (a `logger.info` warning records the no-op).
+  programmatic-mode default is `accept-edits`; use `auto-approve` only as an
+  explicit opt-in.
+- **Tool controls use Vibe's native flags.** The gateway emits one
+  `--enabled-tools <tool>` flag per `allowedTools` entry and one
+  `--disabled-tools <tool>` flag per `disallowedTools` entry. Vibe applies
+  disabled tools after enabled-tool filtering.
 - **No self-update**: `cli_upgrade --cli mistral` detects whether you used
   pip / uv / brew and dispatches the matching upgrade command. Running
   `vibe update` is not a thing.
@@ -992,9 +992,9 @@ Run a Mistral Vibe agentic coding request. Like `grok_request` in shape, but wit
 
 - `model` (string, optional): Vibe model alias (for example `mistral-medium-3.5` or `latest`). The resolved value is injected via the `VIBE_ACTIVE_MODEL` environment variable; omit it to let the gateway discover Vibe config and avoid stale hardcoded defaults.
 - `transport` (string, optional): `"cli"` (default) runs the Vibe CLI; `"acp"` routes through Vibe's native `vibe-acp` transport when `[acp].enabled` and the provider's `runtime_enabled` are set (fails closed otherwise). Sync-only: `mistral_request_async` always runs the CLI transport and does not accept `transport`
-- `permissionMode`: the Vibe `--agent` name — builtins `default | plan | accept-edits | auto-approve`, or any install-gated/custom agent. Emitted as `--agent <name>`. Defaults to `auto-approve` in programmatic mode.
-- `allowedTools` (string[], optional): One `--enabled-tools <tool>` flag per entry (allow-list only).
-- `disallowedTools` (string[], optional): Accepted for parity with the other providers; ignored at the CLI boundary with a logged warning.
+- `permissionMode`: the Vibe `--agent` name: builtins `default | plan | accept-edits | auto-approve`, or any install-gated/custom agent. Emitted as `--agent <name>`. Defaults to `accept-edits` in programmatic mode; use `auto-approve` only as an explicit opt-in.
+- `allowedTools` (string[], optional): One `--enabled-tools <tool>` flag per entry.
+- `disallowedTools` (string[], optional): One `--disabled-tools <tool>` flag per entry, applied after the enabled-tool filter.
 - `outputFormat` (string, optional): Vibe 2.x values are `"text"`, `"json"`, or `"streaming"`; legacy aliases `"plain"` and `"stream-json"` are accepted and normalized before spawn.
 - `sessionId` / `resumeLatest` / `createNewSession`: standard session controls. Current Vibe defaults session logging to enabled; if an older config has `[session_logging] enabled = false`, `doctor --json` surfaces an actionable next-action.
 - `trust` (boolean, optional): Emit `--trust` so Vibe trusts the cwd for this invocation only (not persisted; skips the interactive trust prompt)
@@ -1023,7 +1023,7 @@ Run a Cognition Devin CLI request synchronously (headless print mode, `devin -p`
 - `model` (string, optional): Model name or alias (e.g. `opus`, `latest`)
 - `transport` (string, optional): `"cli"` (default) runs the Devin CLI; `"acp"` routes through Devin's native `devin acp` transport when `[acp].enabled` and the provider's `runtime_enabled` are set (fails closed otherwise). Sync-only: `devin_request_async` always runs the CLI transport and accepts neither `transport` nor `agentType`
 - `agentType` (string, optional): ACP agent variant for `transport: "acp"` (`devin acp --agent-type`): `"summarizer"` (no tools, text summary) or `"review"` (read-only plus shell code-review); ignored for the CLI transport
-- `permissionMode` (string, optional): Devin CLI permission mode (`--permission-mode`): `auto` (auto-approves read-only tools), `smart` (also auto-runs actions a fast model judges safe), `dangerous` (auto-approves all). Omit to use Devin's headless default
+- `permissionMode` (string, optional): Devin CLI permission mode (`--permission-mode`): `auto` (auto-approves read-only tools), `accept-edits` (also auto-approves workspace edits), `smart` (also auto-runs actions a fast model judges safe), `dangerous` (auto-approves all). Omit to use Devin's headless default
 - `promptFile` (string, optional): Load the initial prompt from a file (`--prompt-file`)
 - `sessionId` (string, optional): Devin session ID to resume (`--resume <id>`). The `gw-*` id minted for a brand-new session is not resumable via `sessionId`; continue with `resumeLatest: true`
 - `resumeLatest` (boolean, optional): Resume the most recent Devin session in cwd (`--continue`)
@@ -1653,7 +1653,7 @@ The gateway supports concurrent requests across different CLIs. Each request spa
 - **Command Execution**: Uses `spawn` with separate arguments (not shell execution)
 - **No Eval**: No dynamic code evaluation in our source (see "Socket alerts" below for the transitive `ajv` codegen case)
 - **Sandboxing**: Consider running in containers for production use
-- **npm publish control**: npm releases are gated by the generated prod-only shrinkwrap, release security audit, packed-consumer checks, and a publish token fetched at runtime from Azure Key Vault through GitHub OIDC to Entra
+- **npm publish control**: npm releases are gated by the generated prod-only shrinkwrap, release security audit, packed-consumer checks, and GitHub Actions Trusted Publishing with short-lived OIDC-derived npm publish credentials
 - **Release signing**: GitHub release installer artifacts are signed with Sigstore keyless signing; verify `SHA256SUMS.sigstore.json` before trusting the checksum file
 
 ### Socket alerts — context for reviewers

package/dist/acp/client.js

@@ -1,6 +1,7 @@
 import { AcpMethodUnsupportedError, AcpMutatingDisabledError, AcpProtocolError, isAcpError, } from "./errors.js";
 import { deriveAcpMethodAvailability, parseCloseSessionResponse, parseDeleteSessionResponse, parseInitializeResponse, parseListSessionsResponse, parseReadTextFileRequest, parseRequestPermissionRequest, parseSessionLoadResponse, parseSessionNewResponse, parseSessionPromptResponse, parseSessionResumeResponse, parseSessionUpdateNotification, parseSetSessionConfigOptionResponse, parseSetSessionModeResponse, parseWriteTextFileRequest, sessionResponseMethods, } from "./types.js";
 import { noopLogger } from "../logger.js";
+import { gatewayVersion } from "../provider-capability-discovery.js";
 export const DEFAULT_ACP_PROTOCOL_VERSION = 1;
 export class AcpClient {
     transport;
@@ -47,6 +48,10 @@ export class AcpClient {
         }
         const params = {
             protocolVersion: this.protocolVersion,
+            clientInfo: {
+                name: "llm-cli-gateway",
+                version: gatewayVersion(),
+            },
             clientCapabilities: {
                 fs: {
                     readTextFile: options.readTextFile ?? false,

package/dist/acp/flight-redaction.d.ts

@@ -24,5 +24,7 @@ export interface AcpFlightResultParams {
     readonly errorMessage?: string;
     readonly providerSessionId?: string;
     readonly stopReason?: string;
+    readonly costUsd?: number;
+    readonly costBasis?: string;
 }
 export declare function buildAcpFlightResult(params: AcpFlightResultParams): FlightLogResult;

package/dist/acp/flight-redaction.js

@@ -39,5 +39,7 @@ export function buildAcpFlightResult(params) {
         errorMessage: params.errorMessage !== undefined ? redactAcpTextForFlight(params.errorMessage) : undefined,
         providerSessionId: params.providerSessionId,
         stopReason: params.stopReason,
+        costUsd: params.costUsd,
+        costBasis: params.costBasis,
     };
 }

package/dist/acp/runtime.d.ts

@@ -38,6 +38,7 @@ export interface AcpPromptUsage {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadTokens?: number;
+    reasoningTokens?: number;
 }
 export declare function extractAcpPromptUsage(meta: unknown): AcpPromptUsage;
 export declare function runAcpRequest(deps: AcpRuntimeDeps, req: AcpRunRequest): Promise<AcpRunResult>;

package/dist/acp/runtime.js

@@ -6,6 +6,7 @@ import { createAcpPermissionDecider } from "./permission-bridge.js";
 import { AcpProcessManager } from "./process-manager.js";
 import { createAcpSession, recordAcpSessionInfo, resolveAcpResume } from "./session-map.js";
 import { DEVIN_ACP_AGENT_TYPES } from "../provider-definitions.js";
+import { composeCost, getModelCost } from "../pricing.js";
 import { noopLogger } from "../logger.js";
 export function extractAcpPromptUsage(meta) {
     if (!meta || typeof meta !== "object" || Array.isArray(meta))
@@ -22,6 +23,9 @@ export function extractAcpPromptUsage(meta) {
     const cacheReadTokens = num(record.cachedReadTokens);
     if (cacheReadTokens !== undefined)
         usage.cacheReadTokens = cacheReadTokens;
+    const reasoningTokens = num(record.reasoningTokens);
+    if (reasoningTokens !== undefined)
+        usage.reasoningTokens = reasoningTokens;
     return usage;
 }
 export async function runAcpRequest(deps, req) {
@@ -120,6 +124,20 @@ export async function runAcpRequest(deps, req) {
         const text = normalizer.finalText;
         const durationMs = elapsed();
         const usage = extractAcpPromptUsage(promptResult._meta);
+        let costUsd;
+        let costBasis;
+        const modelCost = getModelCost(req.provider, req.model ?? "default");
+        if (modelCost.source !== "unknown" &&
+            (usage.inputTokens !== undefined || usage.outputTokens !== undefined)) {
+            const composed = composeCost({
+                inputTokens: usage.inputTokens ?? 0,
+                outputTokens: usage.outputTokens ?? 0,
+                cacheReadTokens: usage.cacheReadTokens,
+                reasoningTokens: usage.reasoningTokens,
+            }, { estInputTokens: 0, estOutputTokens: 0 }, modelCost);
+            costUsd = composed.costUsd;
+            costBasis = composed.cost_basis;
+        }
         deps.flightRecorder?.logComplete(req.correlationId, buildAcpFlightResult({
             responseText: text,
             durationMs,
@@ -130,6 +148,8 @@ export async function runAcpRequest(deps, req) {
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             cacheReadTokens: usage.cacheReadTokens,
+            costUsd,
+            costBasis,
         }));
         logger.info("acp.request.success", { provider: req.provider, durationMs });
         return {

package/dist/acp/types.d.ts

@@ -54,8 +54,34 @@ export declare const ClientCapabilitiesSchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>>;
     terminal: z.ZodOptional<z.ZodBoolean>;
 }, z.ZodTypeAny, "passthrough">>;
+export declare const ClientInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
 export declare const InitializeRequestSchema: z.ZodObject<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;
@@ -96,6 +122,19 @@ export declare const InitializeRequestSchema: z.ZodObject<{
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;
@@ -136,6 +175,19 @@ export declare const InitializeRequestSchema: z.ZodObject<{
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     protocolVersion: z.ZodNumber;
+    clientInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        version: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
     clientCapabilities: z.ZodOptional<z.ZodObject<{
         fs: z.ZodOptional<z.ZodObject<{
             readTextFile: z.ZodOptional<z.ZodBoolean>;

package/dist/acp/types.js

@@ -50,9 +50,17 @@ export const ClientCapabilitiesSchema = z
     terminal: z.boolean().optional(),
 })
     .passthrough();
+export const ClientInfoSchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    title: z.string().min(1).optional(),
+})
+    .passthrough();
 export const InitializeRequestSchema = z
     .object({
     protocolVersion: ProtocolVersionSchema,
+    clientInfo: ClientInfoSchema.optional(),
     clientCapabilities: ClientCapabilitiesSchema.optional(),
     _meta: MetaSchema,
 })

package/dist/api-provider.d.ts

@@ -25,6 +25,7 @@ export interface ApiUsage {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadTokens?: number;
+    cacheCreationTokens?: number;
     costUsd?: number;
     raw?: unknown;
 }

package/dist/api-provider.js

@@ -126,6 +126,7 @@ export class AnthropicProvider {
                 inputTokens: firstNumber(usage.input_tokens),
                 outputTokens: firstNumber(usage.output_tokens),
                 cacheReadTokens: firstNumber(usage.cache_read_input_tokens),
+                cacheCreationTokens: firstNumber(usage.cache_creation_input_tokens),
                 raw: usage,
             },
             raw: parsed,

package/dist/async-job-manager.d.ts

@@ -37,6 +37,7 @@ export interface JobLimiterSnapshot {
     timedOut: number;
     saturated: boolean;
 }
+export declare function providerAtCapacity(snapshot: JobLimiterSnapshot, provider: string): boolean;
 export interface AsyncJobFlightRecorderEntry {
     model: string;
     prompt: string;
@@ -53,6 +54,7 @@ export type AsyncJobUsageExtractor = (stdout: string) => {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     costUsd?: number;
+    costBasis?: string;
 };
 export interface AsyncJobSnapshot {
     id: string;
@@ -120,12 +122,25 @@ export declare class AsyncJobManager {
     private sweepTimer;
     private durableAdmission;
     private consecutiveHeartbeatFailures;
+    private consecutiveHeartbeatSuccesses;
+    private lastHeartbeatFailureAt;
+    private lastHeartbeatRecoveryAt;
+    private lastHeartbeatErrorName;
     private skipSweepThisCycle;
     private nextHeartbeatExpectedAt;
     private disposed;
     private readonly pendingWrites;
     constructor(logger?: Logger, onJobComplete?: ((cli: JobProvider, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike, limits?: JobLimitsConfig, _deprecatedOwnsOrphanRecovery?: boolean, leaseConfig?: LeaseRuntimeConfig);
     canAdmitDurableJobs(): boolean;
+    getDurableAdmissionHealth(): {
+        storeAttached: boolean;
+        admitting: boolean;
+        consecutiveHeartbeatFailures: number;
+        consecutiveHeartbeatSuccesses: number;
+        lastHeartbeatFailureAt: string | null;
+        lastHeartbeatRecoveryAt: string | null;
+        lastHeartbeatErrorName: string | null;
+    };
     private assertDurableAdmission;
     private trackPendingWrite;
     dispose(opts?: {
@@ -136,6 +151,7 @@ export declare class AsyncJobManager {
     private onHeartbeatTick;
     runOrphanSweepNow(): void;
     private startReaper;
+    private restoreDurableAdmission;
     private runOrphanSweep;
     private confirmLiveProcessCandidates;
     private recordStartOrFailClosed;