@wardby/cli 0.2.0 → 0.3.0

package/dist/providers/jobs/kubernetes.js

@@ -29,20 +29,26 @@ import { finished } from "node:stream/promises";
 import { createHash } from "node:crypto";
 import { isIP } from "node:net";
 import { logger } from "../../core/logger.js";
-import { MAX_CODING_ARTIFACT_BYTES, parseCodingAgentOutputJson } from "../../coding/protocol.js";
+import { MAX_CODING_ARTIFACT_BYTES, MAX_DEBUG_TRACE_LINE_BYTES, parseCodingAgentOutputJson, } from "../../coding/protocol.js";
 import { CODING_PROXY_DENY_PORT, CODING_PROXY_PORT } from "./docker-isolation.js";
-import { SAFE_WORKER_DIAGNOSTIC } from "./docker.js";
+import { parseWorkerDiagnosticLine } from "./docker.js";
 import { KubernetesAlreadyExistsError, KubernetesConflictError } from "./kubernetes-api.js";
-import { ENFORCEMENT_PROBE_DENY_REACHABLE, ENFORCEMENT_PROBE_PROVEN, ENFORCEMENT_PROBE_DENY_REFUSED, ENFORCEMENT_PROBE_PROXY_UNREACHABLE, KEEPER_CONTAINER, KEEPER_SEEDED_MARKER, KUBERNETES_ISOLATION_ERROR, STORAGE_ROOT, WORKER_CONTAINER, assertRunNetworkPolicyMatches, assertRunPodMatches, buildCapabilitySecret, buildRunNetworkPolicy, buildRunPod, enforcementProbeScript, kubernetesRunNames, kubernetesRunNamesForToken, runLabels, validateKubernetesSpec, } from "./kubernetes-isolation.js";
+import { ENFORCEMENT_PROBE_DENY_REACHABLE, ENFORCEMENT_PROBE_PROVEN, ENFORCEMENT_PROBE_DENY_REFUSED, ENFORCEMENT_PROBE_PROXY_UNREACHABLE, KEEPER_CONTAINER, KEEPER_SEEDED_MARKER, KUBERNETES_ISOLATION_ERROR, STORAGE_ROOT, TOOL_RUNNER_CONTAINER, WORKER_CONTAINER, assertRunNetworkPolicyMatches, assertRunPodMatches, buildCapabilitySecret, buildRunNetworkPolicy, buildRunPod, enforcementProbeScript, kubernetesRunNames, kubernetesRunNamesForToken, runLabels, serviceContainerName, validateKubernetesSpec, } from "./kubernetes-isolation.js";
+import { claudeToolSetup } from "./claude-tool-setup.js";
 import { readProxyWitness } from "./kubernetes-witness.js";
 import { safeExtract } from "./safe-extract.js";
+import { serviceUnreadyError } from "../../coding/services/wording.js";
 import { replaceDirectoryFromStaging } from "./workspace-swap.js";
+import { collectExclusions, normalizeCollectExclusions, tarExcludeArgs, } from "../../coding/collect-exclude.js";
 const BACKEND = "kubernetes";
 const RECORD_SCHEMA_VERSION = 1;
 const RECORD_KEY = "record.json";
 const STOP_GRACE_SECONDS = 10;
 const DIAGNOSTIC_TAIL_LINES = 8;
-const DIAGNOSTIC_LIMIT_BYTES = 4096;
+// The API cuts the tail from its FRONT at limitBytes, so this must hold every
+// tail line at full size: a debug-traced run writes lines of up to
+// MAX_DEBUG_TRACE_LINE_BYTES just before its diagnostic line.
+const DIAGNOSTIC_LIMIT_BYTES = DIAGNOSTIC_TAIL_LINES * MAX_DEBUG_TRACE_LINE_BYTES;
 const MAX_WORKSPACE_ENTRIES = 100_000;
 const MAX_RECORD_ATTEMPTS = 5;
 const READY_POLL_MS = 250;
@@ -51,8 +57,17 @@ const DEFAULT_ENFORCEMENT_TIMEOUT_MS = 30_000;
 const ENFORCEMENT_POLL_MS = 500;
 /** Consecutive proven probes required (8787 reachable, 8788 blocked): one dropped SYN must not open the gate. */
 const ENFORCEMENT_BLOCKED_STREAK = 3;
-/** Bound for one enforcement probe exec (the probe makes two sequential connects, so it gives up after at most 6 s). */
-const ENFORCEMENT_EXEC_TIMEOUT_MS = 10_000;
+/**
+ * Default bound for one enforcement probe exec (the probe makes two sequential connects, so it
+ * gives up after at most 6 s of its own connect timeouts). Overridable per KubernetesJobConfig's
+ * `enforcementExecTimeoutMs` (KUBERNETES_ENFORCEMENT_EXEC_TIMEOUT_MS) — a resource-constrained
+ * keeper (e.g. a laptop `kind` cluster's default 250m CPU / 128Mi limit) can take noticeably
+ * longer than this to run even a healthy probe to completion. DEFAULT_ENFORCEMENT_TIMEOUT_MS
+ * above is exactly this default times ENFORCEMENT_BLOCKED_STREAK, which is not a coincidence: see
+ * the constructor, which derives the effective overall bound the same way from whichever exec
+ * timeout is actually configured, so the two never drift apart.
+ */
+const DEFAULT_ENFORCEMENT_EXEC_TIMEOUT_MS = 10_000;
 /**
  * What the gate reports at its bound, by the last probe's exit code. Each names a different place
  * to look, and each carries the reason in its own message rather than in the documentation: an
@@ -224,6 +239,11 @@ function exitedCleanlyInTime(pod, finishedAt, deadlineAt) {
     const finished = new Date(finishedAt).getTime();
     return Number.isFinite(finished) && finished <= deadlineAt + FINISHED_AT_SKEW_MS;
 }
+/** A Claude run's tool runner that restarted or exited: its socket (and any in-flight command) is gone. */
+function toolRunnerFailed(statuses) {
+    const tool = statuses?.find((status) => status.name === TOOL_RUNNER_CONTAINER);
+    return tool !== undefined && ((tool.restartCount ?? 0) > 0 || tool.state?.terminated !== undefined);
+}
 /** Maps a pod read-back onto the next record state; `undefined` means "no change". Never called for terminal records. */
 function observePod(pod, record, now, readyTimeoutMs) {
     if (!pod) {
@@ -242,6 +262,16 @@ function observePod(pod, record, now, readyTimeoutMs) {
     if (now >= record.deadlineAt || pod.status?.reason === "DeadlineExceeded") {
         return { phase: "failed", result: { exitCode: 124, reason: "timed_out" }, deleteGraceSeconds: STOP_GRACE_SECONDS };
     }
+    // Docker's worker_tool_runner_failed, for the same reason: without its tool runner a Claude worker
+    // can only stall until the deadline. Checked only while the worker still runs, so a clean finish
+    // (checked above) or the pod's own teardown never reads as a tool-runner failure.
+    if (!terminated && toolRunnerFailed(pod.status?.initContainerStatuses)) {
+        return {
+            phase: "failed",
+            result: { exitCode: 1, reason: "failed", diagnostic: "worker_tool_runner_failed" },
+            deleteGraceSeconds: STOP_GRACE_SECONDS,
+        };
+    }
     if (terminated) {
         // An exit 0 that failed the guard above (pod being deleted, no usable finish time) is not a success.
         if (terminated.exitCode === 0)
@@ -328,6 +358,7 @@ export class KubernetesJobLauncher {
     createArchive;
     warn;
     enforcementTimeoutMs;
+    enforcementExecTimeoutMs;
     preflightResult;
     constructor(options) {
         this.options = options;
@@ -339,10 +370,24 @@ export class KubernetesJobLauncher {
         this.now = options.now ?? Date.now;
         this.sleep = options.sleep ?? ((ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms)));
         this.readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
-        this.enforcementTimeoutMs = options.enforcementTimeoutMs ?? DEFAULT_ENFORCEMENT_TIMEOUT_MS;
+        this.enforcementExecTimeoutMs = options.enforcementExecTimeoutMs ?? DEFAULT_ENFORCEMENT_EXEC_TIMEOUT_MS;
+        // Never less than a full blocked-streak's worth of worst-case probes: a longer configured exec
+        // timeout that left this unchanged could make the wall-clock bound expire before the loop ever
+        // has a chance to observe ENFORCEMENT_BLOCKED_STREAK consecutive probes, which would turn "the
+        // keeper is just slow" into an indistinguishable "the policy is not enforced" false negative.
+        // DEFAULT_ENFORCEMENT_TIMEOUT_MS (30_000) already equals the default exec timeout times the
+        // streak (10_000 * 3), so this is a no-op unless a longer exec timeout is actually configured.
+        this.enforcementTimeoutMs = Math.max(options.enforcementTimeoutMs ?? DEFAULT_ENFORCEMENT_TIMEOUT_MS, this.enforcementExecTimeoutMs * ENFORCEMENT_BLOCKED_STREAK);
         this.createArchive = options.createArchive ?? hostTarArchive;
         this.warn = options.onWarning ?? ((message) => kubernetesLog.warn(message));
     }
+    /**
+     * Services run as native sidecars in the run pod (kubernetes-isolation.ts), for either provider:
+     * Claude Code's tool runner is a sidecar in the same pod, so it reaches them on 127.0.0.1 too.
+     */
+    supportsServicesFor(provider) {
+        return provider === "codex" || provider === "claude-code";
+    }
     /**
      * Every per-run object name derives from the run id, so the handle is known before any cluster call.
      * The executor persists it first; a crash mid-launch then still has a handle to clean up with (the
@@ -359,7 +404,19 @@ export class KubernetesJobLauncher {
         }
     }
     async launch(spec) {
-        validateKubernetesSpec(spec);
+        try {
+            validateKubernetesSpec(spec);
+        }
+        catch (error) {
+            // The thrown error already carries the real reason (e.g.
+            // "kubernetes_isolation_unsupported:image-not-registry-digest") and is rethrown unchanged;
+            // this only makes that reason visible to an operator watching logs before the caller (which
+            // may only surface the top-level error code) does anything with it. Nothing here is derived
+            // from spec content beyond that fixed reason tag — no image reference, no limit value.
+            if (error instanceof Error)
+                this.warn(`kubernetes_spec_rejected: ${error.message}`);
+            throw error;
+        }
         await this.runPreflight();
         const names = kubernetesRunNames(spec.runId);
         const handle = { backend: BACKEND, id: `${this.namespace}/${names.token}` };
@@ -376,6 +433,7 @@ export class KubernetesJobLauncher {
             createdAt,
             deadlineAt: createdAt + spec.timeoutSec * 1000,
             phase: "provisioning",
+            collectExclude: spec.collectExclude ?? collectExclusions([]),
         };
         try {
             // The record is the idempotency fence before any other cluster side effect.
@@ -428,7 +486,7 @@ export class KubernetesJobLauncher {
         if (phase === "failed" && !result.diagnostic) {
             const diagnostic = await this.readWorkerDiagnostic(names);
             if (diagnostic)
-                result = { ...result, diagnostic };
+                result = { ...result, ...diagnostic };
         }
         if (phase === "succeeded" && !result.resultArtifact) {
             result = { ...result, resultArtifact: await this.readResultArtifact(names, record.runId) };
@@ -454,7 +512,9 @@ export class KubernetesJobLauncher {
             throw new Error("kubernetes_workspace_destination_invalid");
         }
         const maxBytes = record.diskMb * 1024 * 1024;
-        await replaceDirectoryFromStaging(expected, maxBytes, "kubernetes_workspace_destination_invalid", (staging) => this.extractWorkspace(names, staging, maxBytes, this.transferBudgetMs(record)));
+        await replaceDirectoryFromStaging(expected, maxBytes, "kubernetes_workspace_destination_invalid", (staging) => this.extractWorkspace(names, staging, maxBytes, this.transferBudgetMs(record), 
+        // Names are always the current built-in list; only the paths come from the record.
+        normalizeCollectExclusions(record.collectExclude?.paths)));
     }
     async stop(handle, _reason) {
         const names = this.namesFor(handle);
@@ -532,7 +592,7 @@ export class KubernetesJobLauncher {
             // `exitCode` is this iteration's probe, and the bound below is only ever reached from here —
             // so the verdict is always the *last* probe's, never a remembered earlier one.
             const exitCode = await this.api.exec(this.namespace, names.pod, KEEPER_CONTAINER, command, {
-                timeoutMs: ENFORCEMENT_EXEC_TIMEOUT_MS,
+                timeoutMs: this.enforcementExecTimeoutMs,
             });
             blocked = exitCode === 0 ? blocked + 1 : 0;
             if (blocked >= ENFORCEMENT_BLOCKED_STREAK)
@@ -552,7 +612,7 @@ export class KubernetesJobLauncher {
         return structuredClone(handle);
     }
     async provision(spec, names, record) {
-        const { runtimeClassName, proxyService, platform } = this.options.config;
+        const { runtimeClassName, priorityClassName, proxyService, platform } = this.options.config;
         if (!runtimeClassName) {
             this.warn("kubernetes_runtime_class_unset: no runtime class configured; coding pods run without gVisor (development clusters only)");
         }
@@ -563,12 +623,19 @@ export class KubernetesJobLauncher {
         // which is only meaningful against a Service that actually exposes it with a ready backend.
         const witness = await readProxyWitness(this.api, this.namespace, proxyService);
         const proxyIp = witness.clusterIp;
-        const pod = buildRunPod(spec, { namespace: this.namespace, proxyIp, runtimeClassName, platform });
+        const pod = buildRunPod(spec, {
+            namespace: this.namespace,
+            proxyIp,
+            runtimeClassName,
+            priorityClassName,
+            platform,
+        });
         const policy = buildRunNetworkPolicy(spec, this.namespace);
-        await this.createIfMissing(() => this.api.createSecret(this.namespace, buildCapabilitySecret(spec, this.namespace, capability)));
+        const toolSetup = spec.provider === "claude-code" ? claudeToolSetup(spec, capability) : undefined;
+        await this.createIfMissing(() => this.api.createSecret(this.namespace, buildCapabilitySecret(spec, this.namespace, capability, toolSetup)));
         await this.createIfMissing(() => this.api.createNetworkPolicy(this.namespace, policy));
         await this.createIfMissing(() => this.api.createPod(this.namespace, pod));
-        await this.waitForKeeper(names);
+        await this.waitForKeeper(names, (spec.services ?? []).map((service) => service.name), spec.provider === "claude-code");
         const [actualPod, actualPolicy] = await Promise.all([
             this.api.readPod(this.namespace, names.pod),
             this.api.readNetworkPolicy(this.namespace, names.policy),
@@ -612,7 +679,7 @@ export class KubernetesJobLauncher {
                 throw error;
         }
     }
-    async waitForKeeper(names) {
+    async waitForKeeper(names, serviceNames, toolRunner = false) {
         const started = this.now();
         for (;;) {
             const pod = await this.api.readPod(this.namespace, names.pod);
@@ -620,6 +687,23 @@ export class KubernetesJobLauncher {
                 throw new Error("kubernetes_pod_start_failed");
             const statuses = pod.status?.containerStatuses ?? [];
             const initStatuses = pod.status?.initContainerStatuses ?? [];
+            const sidecar = (name) => initStatuses.find((status) => status.name === serviceContainerName(name));
+            // A service sidecar that restarted (its startup probe gave up), can't be pulled or created, or
+            // exited will never let the keeper start. Name the service rather than a generic start failure.
+            const failedService = serviceNames.find((name) => {
+                const status = sidecar(name);
+                return (status !== undefined &&
+                    ((status.restartCount ?? 0) > 0 ||
+                        FATAL_WAITING_REASONS.has(status.state?.waiting?.reason ?? "") ||
+                        status.state?.terminated !== undefined));
+            });
+            if (failedService !== undefined)
+                throw serviceUnreadyError(failedService);
+            const toolStatus = initStatuses.find((status) => status.name === TOOL_RUNNER_CONTAINER);
+            if (toolRunner &&
+                (toolRunnerFailed(initStatuses) || FATAL_WAITING_REASONS.has(toolStatus?.state?.waiting?.reason ?? ""))) {
+                throw new Error("kubernetes_tool_runner_failed");
+            }
             const keeper = statuses.find((status) => status.name === KEEPER_CONTAINER);
             if ([...initStatuses, ...statuses].some((status) => FATAL_WAITING_REASONS.has(status.state?.waiting?.reason ?? "")) ||
                 // A failed init container (kubectl's Init:Error) or a keeper that already exited can never become ready.
@@ -629,8 +713,17 @@ export class KubernetesJobLauncher {
             }
             if (keeper?.ready === true)
                 return;
-            if (this.now() - started >= this.readyTimeoutMs)
+            if (this.now() - started >= this.readyTimeoutMs) {
+                if (toolRunner && toolStatus?.started !== true) {
+                    throw new Error("kubernetes_tool_runner_unready");
+                }
+                // At the bound, a service that never passed its startup probe (still pulling, still starting)
+                // is why the keeper never started.
+                const waiting = serviceNames.find((name) => sidecar(name)?.started !== true);
+                if (waiting !== undefined)
+                    throw serviceUnreadyError(waiting);
                 throw new Error("kubernetes_pod_start_timeout");
+            }
             await this.sleep(READY_POLL_MS);
         }
     }
@@ -715,14 +808,9 @@ export class KubernetesJobLauncher {
             return undefined;
         }
         for (const line of raw.split("\n").reverse()) {
-            try {
-                const value = JSON.parse(line);
-                if (typeof value?.error === "string" && SAFE_WORKER_DIAGNOSTIC.test(value.error))
-                    return value.error;
-            }
-            catch {
-                // Worker output is untrusted; only one fixed JSON shape is recognized.
-            }
+            const diagnostic = parseWorkerDiagnosticLine(line);
+            if (diagnostic)
+                return diagnostic;
         }
         return undefined;
     }
@@ -759,9 +847,10 @@ export class KubernetesJobLauncher {
      * Streams the keeper's workspace through the strict extractor into `staging`.
      * The transfer is bounded by `timeoutMs` (see transferBudgetMs): on expiry the
      * extraction is aborted. On any failure the output stream this method created
-     * is destroyed, since the exec's own timeout does not end it.
+     * is destroyed, since the exec's own timeout does not end it. Excluded dependency
+     * and cache paths never leave the pod (see src/coding/collect-exclude.ts).
      */
-    async extractWorkspace(names, staging, maxBytes, timeoutMs) {
+    async extractWorkspace(names, staging, maxBytes, timeoutMs, exclusions) {
         const output = new PassThrough();
         // Errors are surfaced through the exec/extraction promises; never let a late destroy() crash the process.
         output.on("error", () => undefined);
@@ -772,10 +861,7 @@ export class KubernetesJobLauncher {
             signal: controller.signal,
         });
         const execution = this.api
-            .exec(this.namespace, names.pod, KEEPER_CONTAINER, ["tar", "-C", WORKSPACE_STORAGE, "-cf", "-", "."], {
-            stdout: output,
-            timeoutMs,
-        })
+            .exec(this.namespace, names.pod, KEEPER_CONTAINER, ["tar", "-C", WORKSPACE_STORAGE, ...tarExcludeArgs(exclusions), "-cf", "-", "."], { stdout: output, timeoutMs })
             .then((exitCode) => {
             if (exitCode !== 0)
                 throw new Error("kubernetes_workspace_archive_failed");

package/dist/providers/jobs/types.d.ts

@@ -3,12 +3,15 @@
  * values are carried in a versioned input artifact, never expanded into an
  * arbitrary environment map or shell command.
  */
+import type { CodingProvider } from "../../coding/provider.js";
 export interface JobResourceLimits {
     cpus: number;
     memoryMb: number;
     pids: number;
     diskMb: number;
 }
+import type { CollectExclusions } from "../../coding/collect-exclude.js";
+import type { ResolvedCodingService } from "../../coding/services/catalog.js";
 export interface JobSpec {
     kind: "coding-agent";
     runId: string;
@@ -21,6 +24,16 @@ export interface JobSpec {
     timeoutSec: number;
     limits: JobResourceLimits;
     labels: Record<string, string>;
+    /** Workspace paths never collected; absent on legacy specs, which get the built-in names. */
+    collectExclude?: CollectExclusions;
+    /**
+     * Coding-run services (docs/coding-services.md): catalog snapshots resolved
+     * at dispatch, started next to the worker. Their images and environments come
+     * from the admin-managed catalog, never from repository content. Absent for
+     * a run without services (never an empty list), so such a spec, and its hash,
+     * is unchanged.
+     */
+    services?: ResolvedCodingService[];
 }
 /** Opaque provider reference. Callers persist both fields exactly as given. */
 export interface JobHandle {
@@ -45,6 +58,8 @@ export interface JobResult {
     resultArtifact?: string;
     /** Fixed worker-owned failure code; never raw container output. */
     diagnostic?: string;
+    /** Output-schema failure locations (`path:code`) that passed SAFE_CODING_OUTPUT_ISSUE; never values. */
+    diagnosticIssues?: string[];
 }
 /**
  * Lifecycle invariants implemented by every launcher:
@@ -75,4 +90,9 @@ export interface JobLauncher {
 /** A launcher that can safely copy a terminal worker workspace back to trusted storage. */
 export interface WorkspaceJobLauncher extends JobLauncher {
     materializeWorkspace: (handle: JobHandle, destination: string) => Promise<void>;
+    /**
+     * Whether this launcher starts JobSpec.services for a run of `provider`: Kubernetes and Docker, for
+     * Codex and Claude Code. Absent means no services at all.
+     */
+    supportsServicesFor?(provider: CodingProvider): boolean;
 }

package/dist/providers/llm/anthropic.js

@@ -6,7 +6,7 @@
  */
 import Anthropic from "@anthropic-ai/sdk";
 import { ClaudeLlmProvider } from "./claude-provider.js";
-import { anthropicPriceUsd, getAnthropicPricing } from "./pricing-anthropic.js";
+import { anthropicPriceUsd, anthropicSupportedEfforts, getAnthropicPricing } from "./pricing-anthropic.js";
 export { anthropicSupportedModels } from "./pricing-anthropic.js";
 export function anthropicCredentialsPresent(env = process.env) {
     return Boolean(env.ANTHROPIC_API_KEY);
@@ -16,6 +16,10 @@ export class AnthropicLlmProvider extends ClaudeLlmProvider {
         if (!client && !apiKey) {
             throw new Error("ANTHROPIC_API_KEY is not set — required by the Anthropic LlmProvider adapter.");
         }
-        super(client ?? new Anthropic({ apiKey }), { getPricing: getAnthropicPricing, priceUsd: anthropicPriceUsd });
+        super(client ?? new Anthropic({ apiKey }), {
+            getPricing: getAnthropicPricing,
+            priceUsd: anthropicPriceUsd,
+            supportedEfforts: anthropicSupportedEfforts,
+        });
     }
 }

package/dist/providers/llm/bedrock.js

@@ -12,7 +12,7 @@
  */
 import { AnthropicBedrock } from "@anthropic-ai/bedrock-sdk";
 import { ClaudeLlmProvider } from "./claude-provider.js";
-import { bedrockClaudePriceUsd, getBedrockClaudePricing } from "./pricing-bedrock-claude.js";
+import { bedrockClaudePriceUsd, bedrockClaudeSupportedEfforts, getBedrockClaudePricing, } from "./pricing-bedrock-claude.js";
 export { bedrockClaudeSupportedModels } from "./pricing-bedrock-claude.js";
 export function bedrockCredentialsPresent(env = process.env) {
     // A region is the one thing Bedrock always needs; AWS resolves actual
@@ -28,6 +28,7 @@ export class BedrockClaudeLlmProvider extends ClaudeLlmProvider {
         super(client ?? new AnthropicBedrock({ awsRegion: region }), {
             getPricing: getBedrockClaudePricing,
             priceUsd: bedrockClaudePriceUsd,
+            supportedEfforts: bedrockClaudeSupportedEfforts,
         });
     }
 }

package/dist/providers/llm/claude-messages.d.ts

@@ -1,4 +1,4 @@
-import type { LlmMessage, LlmRequest, LlmToolDef, LlmStreamEvent, LlmUsage } from "./types.js";
+import type { LlmEffort, LlmMessage, LlmRequest, LlmToolDef, LlmStreamEvent, LlmUsage } from "./types.js";
 export interface CacheControl {
     type: "ephemeral";
 }
@@ -36,6 +36,10 @@ export interface ClaudeRequest {
     messages: ClaudeMessage[];
     tools?: ClaudeTool[];
     max_tokens: number;
+    /** Present only when an effort is set; omitted means the API default. */
+    output_config?: {
+        effort: LlmEffort;
+    };
 }
 /**
  * Same shape sent to the API in `toClaudeRequest` — kept as one function so

package/dist/providers/llm/claude-messages.js

@@ -77,6 +77,7 @@ export function toClaudeRequest(req, defaultMaxTokens) {
         messages,
         ...(tools && tools.length > 0 ? { tools } : {}),
         max_tokens: req.maxTokens ?? defaultMaxTokens,
+        ...(req.effort ? { output_config: { effort: req.effort } } : {}),
     };
 }
 const EPHEMERAL = { type: "ephemeral" };

package/dist/providers/llm/claude-provider.d.ts

@@ -5,7 +5,7 @@
  * stays exactly what each concrete adapter (anthropic.ts, bedrock.ts) has in
  * common, and nothing more.
  */
-import type { LlmMessage, LlmProvider, LlmRequest, LlmStreamEvent, LlmToolDef } from "./types.js";
+import type { LlmEffort, LlmMessage, LlmProvider, LlmRequest, LlmStreamEvent, LlmToolDef } from "./types.js";
 import type { ModelPricing, UsageTokens } from "./pricing-core.js";
 /**
  * Structural shape every Claude-protocol SDK client satisfies. Loose on
@@ -24,6 +24,8 @@ export interface ClaudePricingModule {
     /** Must throw on an unknown model — fail-closed, never price at zero. */
     getPricing(model: string): ModelPricing;
     priceUsd(model: string, usage: UsageTokens): number;
+    /** Effort levels the model accepts; empty = never send an effort. */
+    supportedEfforts(model: string): readonly LlmEffort[];
 }
 export declare class ClaudeLlmProvider implements LlmProvider {
     private readonly client;

package/dist/providers/llm/claude-provider.js

@@ -17,7 +17,11 @@ export class ClaudeLlmProvider {
         this.pricing = pricing;
     }
     async *stream(req, signal) {
-        const claudeReq = withCacheBreakpoints(toClaudeRequest(req, DEFAULT_MAX_TOKENS));
+        // Defence in depth behind config-time validation: a level the model
+        // doesn't accept would fail the whole call, so it is dropped here.
+        const { effort, ...rest } = req;
+        const accepted = effort && this.pricing.supportedEfforts(req.model).includes(effort);
+        const claudeReq = withCacheBreakpoints(toClaudeRequest(accepted ? { ...rest, effort } : rest, DEFAULT_MAX_TOKENS));
         const raw = this.client.messages.stream({ model: req.model, ...claudeReq }, { signal });
         yield* mapClaudeStream(raw, (usage) => this.priceUsd(req.model, usage));
     }

package/dist/providers/llm/index.d.ts

@@ -6,5 +6,5 @@ export { BedrockClaudeLlmProvider, bedrockCredentialsPresent, bedrockClaudeSuppo
 export { ClaudeLlmProvider, type ClaudeMessagesClient, type ClaudePricingModule } from "./claude-provider.js";
 export { openaiCredentialsPresent } from "./openai.js";
 export { supportedModels as openaiSupportedModels } from "./pricing.js";
-export { RoutingLlmProvider, type LlmRegistration } from "./routing.js";
+export { RoutingLlmProvider, modelAcceptsEffort, modelSupportedEfforts, type LlmRegistration } from "./routing.js";
 export { resolveLlmRegistrations, type LlmRegistrationResult } from "./registration.js";

package/dist/providers/llm/index.js

@@ -6,5 +6,5 @@ export { BedrockClaudeLlmProvider, bedrockCredentialsPresent, bedrockClaudeSuppo
 export { ClaudeLlmProvider } from "./claude-provider.js";
 export { openaiCredentialsPresent } from "./openai.js";
 export { supportedModels as openaiSupportedModels } from "./pricing.js";
-export { RoutingLlmProvider } from "./routing.js";
+export { RoutingLlmProvider, modelAcceptsEffort, modelSupportedEfforts } from "./routing.js";
 export { resolveLlmRegistrations } from "./registration.js";

package/dist/providers/llm/pricing-anthropic.d.ts

@@ -1,4 +1,14 @@
+/**
+ * Anthropic direct-API pricing table. Every entry is a fully literal,
+ * hardcoded ModelPricing — every field, including cache read/write, is the
+ * provider's own published rate for that exact model, never derived from
+ * another field via a ratio (see CLAUDE.md "LLM pricing tables — STRICT": a
+ * multiplier that happens to be correct today silently goes stale the
+ * moment one model's real cache pricing diverges from the pattern).
+ */
 import { type ModelPricing, type UsageTokens } from "./pricing-core.js";
+import type { LlmEffort } from "./types.js";
+export declare function anthropicSupportedEfforts(model: string): readonly LlmEffort[];
 export declare function getAnthropicPricing(model: string): ModelPricing;
 export declare function anthropicSupportedModels(): string[];
 export declare function anthropicPriceUsd(model: string, usage: UsageTokens): number;

package/dist/providers/llm/pricing-anthropic.js

@@ -1,21 +1,39 @@
+/**
+ * Anthropic direct-API pricing table. Every entry is a fully literal,
+ * hardcoded ModelPricing — every field, including cache read/write, is the
+ * provider's own published rate for that exact model, never derived from
+ * another field via a ratio (see CLAUDE.md "LLM pricing tables — STRICT": a
+ * multiplier that happens to be correct today silently goes stale the
+ * moment one model's real cache pricing diverges from the pattern).
+ */
 import { computeCost } from "./pricing-core.js";
-const CACHE_READ_MULT = 0.1;
-const CACHE_WRITE_MULT = 1.25;
-function claude(inputPerMTok, outputPerMTok) {
-    return {
-        encoding: "o200k_base",
-        inputPerMTok,
-        outputPerMTok,
-        cachedInputPerMTok: inputPerMTok * CACHE_READ_MULT,
-        cacheWritePerMTok: inputPerMTok * CACHE_WRITE_MULT,
-    };
+function claude(inputPerMTok, outputPerMTok, cachedInputPerMTok, cacheWritePerMTok) {
+    return { encoding: "o200k_base", inputPerMTok, outputPerMTok, cachedInputPerMTok, cacheWritePerMTok };
 }
+// Rates are the exact published 5-minute cache-TTL numbers
+// (platform.claude.com/docs/en/about-claude/pricing, "Model pricing" table)
+// — wardby only ever emits the default 5-minute cache_control breakpoint,
+// so the 1-hour-TTL rates are out of scope and not stored here.
 const PRICING = {
-    "claude-opus-5": claude(5, 25),
-    "claude-sonnet-5": claude(2, 10),
-    "claude-fable-5": claude(10, 50),
-    "claude-haiku-4-5": claude(1, 5),
+    "claude-opus-5": claude(5, 25, 0.5, 6.25),
+    "claude-sonnet-5": claude(2, 10, 0.2, 2.5),
+    "claude-fable-5": claude(10, 50, 1, 12.5),
+    "claude-haiku-4-5": claude(1, 5, 0.1, 1.25),
 };
+// Reasoning effort levels each model accepts (`output_config.effort`). The
+// single source of truth for direct-API Claude models; a model missing here
+// accepts no effort, so a new roster entry never gets one by accident.
+// Haiku 4.5 rejects the parameter outright.
+const ALL_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const EFFORTS = {
+    "claude-opus-5": ALL_EFFORTS,
+    "claude-sonnet-5": ALL_EFFORTS,
+    "claude-fable-5": ALL_EFFORTS,
+    "claude-haiku-4-5": [],
+};
+export function anthropicSupportedEfforts(model) {
+    return EFFORTS[model] ?? [];
+}
 export function getAnthropicPricing(model) {
     const p = PRICING[model];
     if (!p)

package/dist/providers/llm/pricing-bedrock-claude.d.ts

@@ -7,6 +7,14 @@
  * moment one model's real cache pricing diverges from the pattern).
  */
 import { type ModelPricing, type UsageTokens } from "./pricing-core.js";
+import type { LlmEffort } from "./types.js";
 export declare function getBedrockClaudePricing(model: string): ModelPricing;
 export declare function bedrockClaudeSupportedModels(): string[];
+/**
+ * Reasoning effort is not sent through Bedrock: whether InvokeModel accepts
+ * the Messages `output_config.effort` field for these models is unconfirmed,
+ * and an unaccepted field fails the whole call. Every Bedrock model therefore
+ * accepts no effort until that is verified per model.
+ */
+export declare function bedrockClaudeSupportedEfforts(_model: string): readonly LlmEffort[];
 export declare function bedrockClaudePriceUsd(model: string, usage: UsageTokens): number;

package/dist/providers/llm/pricing-bedrock-claude.js

@@ -32,6 +32,15 @@ export function getBedrockClaudePricing(model) {
 export function bedrockClaudeSupportedModels() {
     return Object.keys(PRICING);
 }
+/**
+ * Reasoning effort is not sent through Bedrock: whether InvokeModel accepts
+ * the Messages `output_config.effort` field for these models is unconfirmed,
+ * and an unaccepted field fails the whole call. Every Bedrock model therefore
+ * accepts no effort until that is verified per model.
+ */
+export function bedrockClaudeSupportedEfforts(_model) {
+    return [];
+}
 export function bedrockClaudePriceUsd(model, usage) {
     return computeCost(getBedrockClaudePricing(model), usage);
 }

package/dist/providers/llm/routing.d.ts

@@ -4,7 +4,16 @@
  * selection (Agent.model) selects the provider too — GPT and Claude agents
  * run in one deployment. Unknown model / duplicate registration fail closed.
  */
-import type { LlmMessage, LlmProvider, LlmRequest, LlmStreamEvent, LlmToolDef } from "./types.js";
+import type { LlmEffort, LlmMessage, LlmProvider, LlmRequest, LlmStreamEvent, LlmToolDef } from "./types.js";
+/**
+ * Effort levels `model` accepts, whichever provider owns it — for config-time
+ * validation, so it needs no credentials. Each provider's own table is the
+ * source of truth. OpenAI models accept none: the Chat Completions
+ * `reasoning_effort` parameter is documented for o-series models only, and
+ * none is on the roster.
+ */
+export declare function modelSupportedEfforts(model: string): readonly LlmEffort[];
+export declare function modelAcceptsEffort(model: string, effort: LlmEffort): boolean;
 export interface LlmRegistration {
     provider: LlmProvider;
     models: string[];

package/dist/providers/llm/routing.js

@@ -1,3 +1,21 @@
+import { anthropicSupportedEfforts } from "./pricing-anthropic.js";
+import { bedrockClaudeSupportedEfforts } from "./pricing-bedrock-claude.js";
+/**
+ * Effort levels `model` accepts, whichever provider owns it — for config-time
+ * validation, so it needs no credentials. Each provider's own table is the
+ * source of truth. OpenAI models accept none: the Chat Completions
+ * `reasoning_effort` parameter is documented for o-series models only, and
+ * none is on the roster.
+ */
+export function modelSupportedEfforts(model) {
+    const direct = anthropicSupportedEfforts(model);
+    if (direct.length > 0)
+        return direct;
+    return bedrockClaudeSupportedEfforts(model);
+}
+export function modelAcceptsEffort(model, effort) {
+    return modelSupportedEfforts(model).includes(effort);
+}
 export class RoutingLlmProvider {
     byModel = new Map();
     constructor(registrations) {

package/dist/providers/llm/types.d.ts

@@ -35,6 +35,13 @@ export interface LlmToolDef {
     /** JSON Schema for the tool's parameters. */
     parameters: Record<string, unknown>;
 }
+/**
+ * Reasoning effort levels, lowest to highest. Which levels a model accepts
+ * is per model and per provider — ask `modelSupportedEfforts` (routing.ts).
+ */
+export declare const LLM_EFFORT_LEVELS: readonly ["low", "medium", "high", "xhigh", "max"];
+export type LlmEffort = (typeof LLM_EFFORT_LEVELS)[number];
+export declare function isLlmEffort(value: unknown): value is LlmEffort;
 export interface LlmRequest {
     model: string;
     messages: LlmMessage[];
@@ -42,6 +49,11 @@ export interface LlmRequest {
     maxTokens?: number;
     temperature?: number;
     stopSequences?: string[];
+    /**
+     * Reasoning effort. Unset = the provider's own default. An adapter sends
+     * it only when the model accepts that level, and drops it otherwise.
+     */
+    effort?: LlmEffort;
 }
 export interface LlmUsage {
     /** Total input tokens, including any served from cache. */

package/dist/providers/llm/types.js

@@ -9,4 +9,11 @@
  * Selected per-agent by RoutingLlmProvider (Agent.model -> provider).
  * Bedrock-hosted Claude is a reserved future adapter (shared claude-messages.ts core).
  */
-export {};
+/**
+ * Reasoning effort levels, lowest to highest. Which levels a model accepts
+ * is per model and per provider — ask `modelSupportedEfforts` (routing.ts).
+ */
+export const LLM_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+export function isLlmEffort(value) {
+    return typeof value === "string" && LLM_EFFORT_LEVELS.includes(value);
+}