llm-cli-gateway 2.15.0 → 2.17.0

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,83 @@ All notable changes to the llm-cli-gateway project.
 
 ## [Unreleased]
 
+## [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
+
+- **Native outbound display-text compressor, PR-1 (#151).** A built-in,
+  provider-agnostic compressor that shrinks provider display text before it is
+  returned to the caller. It is ANSI- and fence-aware (protects code fences,
+  inline code, OSC sequences, and wide characters from lossy rewriting) and is
+  **off by default**; opt in per the compressor configuration. This is the first
+  slice; response-side wiring and API-provider coverage are named follow-ups.
+- **Site machine-discovery generation (#169).** The machine-readable discovery
+  artifacts under `site/` (`llms.txt`, `.well-known/*`, `tools.md`,
+  `openapi.json`, ...) are now generated from the live MCP tool surface by
+  `scripts/generate-site-discovery.mjs`. Regenerate with `npm run site:generate`;
+  `npm run site:generate:check` + `npm run site:validate` gate them in
+  `npm run check` so the published surface can never silently drift from the
+  tools the server actually exposes.
+
+### Changed
+
+- **Vibe/Mistral no longer defaults to `--agent auto-approve` (#155).** Under the
+  default `legacy` approval strategy, Vibe was spawned in auto-approve ("YOLO"),
+  auto-executing every tool call including shell. It now defaults to
+  `--agent accept-edits` (auto-accept file edits; dangerous ops such as shell stay
+  gated, and Vibe denies rather than blocks on them in programmatic mode), matching
+  the `mcp_managed` posture and the other providers' non-bypass defaults. This
+  shrinks the blast radius of a prompt-injected tool call. `auto-approve` remains
+  reachable deliberately: pass `permissionMode: "auto-approve"` on the request, or
+  set `LLM_GATEWAY_APPROVAL_ALLOW_BYPASS` operator-wide. **Behaviour change:**
+  `legacy` callers that relied on Vibe running shell unattended will now see the
+  gated op denied unless they adopt one of those opt-ins.
+- **Provider contract and target-version refreshes (#157 through #171).**
+  `PROVIDER_TARGET_VERSIONS` is now the single source of truth for provider
+  target versions (#165), and every provider's declared upstream contract was
+  re-probed against the installed CLI and refreshed: codex-cli 0.144.1, claude
+  2.1.206, grok 0.2.93, gemini/agy 1.1.0, mistral vibe 2.19.1 (with
+  `--disabled-tools` acknowledged, #170), cursor-agent 2026.07.09, and the devin
+  ACP target 3000.1.27. Internal metadata only; no request-time behaviour change.
+
+### Security
+
+- **Opt-in isolation of provider child-process environment (#154).** A new
+  `LLM_GATEWAY_ISOLATE_SPAWN_ENV` opt-in scrubs the spawned provider CLI's
+  environment at the single `spawnCliProcess` chokepoint, shrinking the blast
+  radius of a hostile provider attempting to exfiltrate redirected/inherited
+  environment secrets.
+- **Installer Go toolchain bumped 1.26.4 to 1.26.5 (#166).** Clears a Go stdlib
+  vulnerability (GO-2026-4970) in the shipped installer binaries.
+
 ## [2.15.0] - 2026-07-03
 
 ### Added
@@ -32,7 +109,7 @@ All notable changes to the llm-cli-gateway project.
 - **Durable instance-lease orphan recovery (#139).** The blanket
   `markOrphanedOnStartup` sweep in the `AsyncJobManager` constructor rewrote
   every `running` row to `orphaned`, so on a SHARED store (`backend =
-  "postgres"`) a fresh instance (especially an ephemeral stdio spawn)
+"postgres"`) a fresh instance (especially an ephemeral stdio spawn)
   transiently orphaned other live instances' in-flight jobs (a `running` ->
   `orphaned` -> `completed` flap a poller can trip on). The sweep is now a
   per-job fencing lease: each instance registers a lease and advances a

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/process-manager.js

@@ -6,6 +6,7 @@ import { AcpError, AcpProcessExitError, ProviderUnavailableError } from "./error
 import { JsonRpcStdioTransport, } from "./json-rpc-stdio.js";
 import { getAcpProviderEntry } from "./provider-registry.js";
 import { envWithExtendedPath, getExtendedPath } from "../executor.js";
+import { applySpawnEnvIsolation } from "../spawn-env-isolation.js";
 import { noopLogger } from "../logger.js";
 const SHUTDOWN_KILL_GRACE_MS = 5000;
 const SHELL_METACHARACTERS = /[\s|&;<>(){}$`"'\\*?[\]~#! ]/;
@@ -15,7 +16,7 @@ function assertSafeExecutable(command, provider) {
     }
 }
 export function buildProviderEnv(provider, providerConfig, baseEnv) {
-    const env = envWithExtendedPath(baseEnv, getExtendedPath());
+    const env = applySpawnEnvIsolation(envWithExtendedPath(baseEnv, getExtendedPath()));
     if (provider === "grok" && providerConfig.isolatedLeaderSocket) {
         const socketDir = tmpdir();
         const socketName = `grok-acp-leader-${process.pid}-${Date.now()}.sock`;

package/dist/acp/provider-registry.js

@@ -1,4 +1,4 @@
-import { getProviderDefinition } from "../provider-definitions.js";
+import { getProviderDefinition, PROVIDER_TARGET_VERSIONS } from "../provider-definitions.js";
 function acpEntrypointFromDefinition(provider) {
     const entry = getProviderDefinition(provider).acp.entrypoint;
     if (!entry) {
@@ -12,7 +12,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Mistral Vibe",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "vibe 2.18.3",
+        targetVersion: PROVIDER_TARGET_VERSIONS.mistral,
         entrypoint: acpEntrypointFromDefinition("mistral"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -25,7 +25,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "xAI Grok CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "grok 0.2.77 (44e77bec3a)",
+        targetVersion: PROVIDER_TARGET_VERSIONS.grok,
         entrypoint: acpEntrypointFromDefinition("grok"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -38,7 +38,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "OpenAI Codex CLI",
         status: "adapter_mediated_deferred",
         supportKind: "adapter_mediated",
-        targetVersion: "codex-cli 0.142.4",
+        targetVersion: PROVIDER_TARGET_VERSIONS.codex,
         entrypoint: acpEntrypointFromDefinition("codex"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -51,7 +51,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Anthropic Claude Code",
         status: "adapter_mediated_deferred",
         supportKind: "adapter_mediated",
-        targetVersion: "claude 2.1.198",
+        targetVersion: PROVIDER_TARGET_VERSIONS.claude,
         entrypoint: acpEntrypointFromDefinition("claude"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -64,7 +64,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Google Antigravity",
         status: "absent_watchlist",
         supportKind: "none",
-        targetVersion: "agy 1.0.14",
+        targetVersion: PROVIDER_TARGET_VERSIONS.gemini,
         entrypoint: acpEntrypointFromDefinition("gemini"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -77,7 +77,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Cognition Devin CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "devin 2026.8.18 (16737566)",
+        targetVersion: PROVIDER_TARGET_VERSIONS.devin,
         entrypoint: acpEntrypointFromDefinition("devin"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -90,7 +90,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Cursor Agent CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "cursor-agent 2026.06.29-2ad2186",
+        targetVersion: PROVIDER_TARGET_VERSIONS.cursor,
         entrypoint: acpEntrypointFromDefinition("cursor"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,

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;
@@ -45,6 +46,7 @@ export interface AsyncJobFlightRecorderEntry {
     stablePrefixTokens?: number;
     cacheControlBlocks?: number;
     cacheControlTtlSeconds?: number;
+    optimizationApplied?: boolean;
 }
 export type AsyncJobUsageExtractor = (stdout: string) => {
     inputTokens?: number;
@@ -52,6 +54,7 @@ export type AsyncJobUsageExtractor = (stdout: string) => {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     costUsd?: number;
+    costBasis?: string;
 };
 export interface AsyncJobSnapshot {
     id: string;
@@ -91,6 +94,7 @@ export interface StartJobOptions {
     writeFlightStart?: boolean;
     flightRecorderEntry?: AsyncJobFlightRecorderEntry;
     extractUsage?: AsyncJobUsageExtractor;
+    compressResponse?: boolean;
 }
 export interface StartJobOutcome {
     snapshot: AsyncJobSnapshot;
@@ -118,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?: {
@@ -134,6 +151,7 @@ export declare class AsyncJobManager {
     private onHeartbeatTick;
     runOrphanSweepNow(): void;
     private startReaper;
+    private restoreDurableAdmission;
     private runOrphanSweep;
     private confirmLiveProcessCandidates;
     private recordStartOrFailClosed;
@@ -169,7 +187,7 @@ export declare class AsyncJobManager {
     private persistComplete;
     private hydrateFromStore;
     getJobOwner(jobId: string): string | null | undefined;
-    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean, stdin?: string): AsyncJobSnapshot;
+    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean, stdin?: string, compressResponse?: boolean): AsyncJobSnapshot;
     startJobWithDedup(cli: LlmCli, args: string[], correlationId: string, opts?: StartJobOptions): StartJobOutcome;
     private launchProcessJob;
     private failQueuedJob;
@@ -199,6 +217,7 @@ export declare class AsyncJobManager {
     getLimiterSnapshot(): JobLimiterSnapshot;
     getConfiguredLimits(): JobLimitsConfig;
     getJobOutputFormat(jobId: string): string | undefined;
+    getJobCompressResponse(jobId: string): boolean;
     getJobCli(jobId: string): JobProvider | undefined;
     private snapshot;
     private appendOutput;