glm-coding-router 1.1.2 → 2.0.0

package/README.md

@@ -41,6 +41,10 @@ Claude / Codex → shell → glm-worker → claude.exe harness → Z.ai endpoint
                     GLM-5.3 / GLM-5.3-Flash
 ```
 
+For headless worker/review runs, the router also consumes Claude Code's stream-json output,
+records a provider-neutral event history, and renders progress on stderr. Interactive
+`glm-chat` / `glm-fast` sessions keep the direct pass-through path shown above.
+
 ## Requirements
 
 - Windows 10/11 or Linux (both verified); macOS is experimental — the suite has not been
@@ -122,10 +126,17 @@ go test ./internal/auth/...
 "@ | glm-worker
 ```
 
-Input priority: **stdin → arguments → error**. The worker runs with
+Input priority: **arguments → stdin → error**. Arguments win, and stdin is not even
+read when they carry a prompt — waiting for EOF on a pipe that never closes (an agent
+harness, CI, `nohup`) would hang the run before it started. The worker runs with
 `--max-turns 20 --permission-mode acceptEdits --tools Read,Glob,Grep,Edit,Write,Bash`.
 It never uses `--dangerously-skip-permissions`.
 
+Routing flags (v2): `--model main|fast` pins the config slot for this run (it does not
+bypass an enforced refusal), `--force` overrides one, `--refresh-quota` re-reads the
+Z.ai quota instead of the 60 s cache — see [Quota-aware routing](#quota-aware-routing-v2).
+Like `--profile`, they belong to the wrapper and are consumed before the prompt is read.
+
 ## glm-review
 
 Read-only worker for repository exploration, call-graph discovery, duplicate detection,
@@ -190,7 +201,7 @@ your work; the footer prints the path and the merge command:
 [glm-router] next: inspect it, then merge glm/delegate/backend (or discard with git worktree remove)
 ```
 
-- Prompt priority is stdin → arguments, same as `glm-worker`.
+- Prompt priority is arguments → stdin, same as `glm-worker`.
 - Profiles: `--profile test` explicitly, or — when omitted — a profile literally
   named after the delegate (`delegate test` → the `test` profile) if one exists.
 - `--remove` deletes the worktree **after a successful run only**; plain
@@ -261,6 +272,93 @@ glm-router usage
 
 `--json` emits the same data machine-readably. No key configured → `ERROR [10]`.
 
+## Run observability (v2)
+
+Every `glm-worker` / `glm-review` run — and every MCP `glm_worker` / `glm_review` call —
+is instrumented: the child runs with `--output-format stream-json`, events are recorded
+under `<configDir>/runs/`, and progress renders live on **stderr**. Stdout stays exactly
+the final assistant text, so pipes, orchestrators, and `benchmark` keep working unchanged.
+
+- `runs/history/YYYY-MM-DD/<runId>/` holds `events.jsonl` (one JSON event per line) and
+  `summary.json`; `runs/active/` registers live runs with a heartbeat.
+- Progress modes: `rich` (box + turn tree, TTY only), `nested` (one `[GLM] …` line per
+  significant event — the default when stderr is piped), `off`. `--no-progress`,
+  `--quiet`, or `CI=true` force `off`; `GLM_ROUTER_PROGRESS=off|rich|nested` and
+  `GLM_ROUTER_NESTED=1` override config; `ui.mode` is the standing default.
+- `GLM_ROUTER_OBSERVE=off` restores the exact v1 path (also automatic when the caller
+  passes its own `--output-format`, as `benchmark` does).
+
+```powershell
+glm-router runs                     # id, state, model, started, duration, turns, files
+glm-router runs --active --limit 5
+glm-router runs show <runId>        # metadata, summary, per-turn tool tree
+glm-router runs logs <runId>        # events.jsonl, one line per event (--json = raw)
+glm-router runs clean --dry-run --orphans  # preview retention prune + orphan reap
+glm-router watch                    # attach to the newest active run, follow live
+glm-router dashboard                # quota + active runs + recent runs
+```
+
+- `runs show` accepts a unique id suffix; the whole family supports `--json`.
+- `runs clean --older-than 30d` prunes by age, `--orphans` reaps active runs whose
+  process is gone; history is also pruned at run start (`history.retentionDays: 30`,
+  `history.maxRuns: 1000` by default).
+- `watch [run-id] [--from-start]` renders through the same renderer as a live run; no active
+  run → a message, exit 0.
+- `dashboard` repaints every `--interval` seconds (default 2) on a TTY; piped, it
+  prints one snapshot and exits. Ctrl+C quits the live view.
+
+**Checkpoints and handoff bundles.** A run that dies with work on disk — child failure,
+crash, kill — always leaves a bundle in `<runDir>/handoff/`: `checkpoint.json` (phase,
+completed turns, pending work, files changed, validations owed), `diff.patch` (the real
+`git diff`; the router never runs `git add`, so untracked files are listed separately),
+`handoff.md`, and `handoff.json`. The bundle path is printed to stderr. Outside a git
+repo the bundle is still written, minus the patch.
+
+## Quota-aware routing (v2)
+
+Before spawning, the router reads the Z.ai quota (cached 60 s), classifies the task, and
+estimates its cost (p90 from `cost-samples.jsonl` history, else a built-in baseline).
+The binding window (5-hour vs weekly, whichever is lower) picks a zone: HEALTHY runs the
+main model; CONSERVE, HANDOFF_READY, and CRITICAL prefer the fast one. If main does not
+fit the usable budget but fast does, the run is downgraded — never the reverse. Endpoint
+unreachable, no key, or an empty payload → `confidence: "unknown"` → run normally and
+warn once on stderr: a monitoring outage never blocks work.
+
+Defaults in 2.0.0: `quotaAware: true`, but `refuseOnCritical: false` and
+`handoffOnLowQuota: false` — the shipped router observes, downgrades, and warns; it
+never refuses a run and never kills a live child. Every `summary.json` records
+`routingAdvice` (`zone`, `wouldRefuse`, `estimatedCost`, `actualCredits`), the evidence
+for revisiting those switches later.
+
+```json
+{
+  "routing": {
+    "quotaAware": true, "refuseOnCritical": false, "handoffOnLowQuota": false,
+    "reserveRatio": 0.10, "safetyFactor": 1.3,
+    "preferFlashBelow": 0.30, "handoffReadyBelow": 0.15, "criticalBelow": 0.08,
+    "pollIntervalSec": 60, "quotaCacheTtlSec": 60
+  },
+  "history": { "retentionDays": 30, "maxRuns": 1000 },
+  "ui": { "mode": "auto", "color": true }
+}
+```
+
+Ratio fields must satisfy `0 < x < 1` and stay ordered
+(`criticalBelow < handoffReadyBelow < preferFlashBelow`), else `ERROR [11]`.
+
+**Exit 41 / 42 — unfinished, not crashed.** Both mean "work preserved", and both print a
+`HandoffResult` JSON on stdout:
+
+- **41 `QUOTA_INSUFFICIENT`** — preflight refused to spawn anything (reachable only
+  with `refuseOnCritical: true`). Nothing ran, and no run-history or repository files
+  were written; `--model fast` may fit the budget, `--force` overrides the refusal.
+- **42 `HANDOFF_REQUIRED`** — a live run was stopped at a safe tool boundary and handed
+  back (reachable only with `handoffOnLowQuota: true`); the JSON carries `handoff_path`.
+
+An orchestrator reads 41/42 as "continue in the same worktree", never as "the worker
+broke". A child that fails on its own still exits 40 — the handoff bundle is written
+anyway.
+
 ## Agent skills (Claude Code + Codex)
 
 `glm-router skill install` writes the `glm-delegation` SKILL.md into **both**
@@ -292,7 +390,9 @@ glm-router mcp remove      # claude mcp remove -s user glm-coding-router
 
 Tool-level failures return `isError` results (missing key, no claude, outside
 a git repo, unreachable endpoint); the server never prints anything to stdout
-except JSON-RPC frames.
+except JSON-RPC frames. MCP-driven runs are recorded like any other (registry on,
+progress renderer off), so they appear in `glm-router runs` and `dashboard` while
+the protocol channel stays clean.
 
 ## CLI reference
 
@@ -307,6 +407,9 @@ glm-router config set models.main glm-5.3
 glm-router delegate <name>   run a GLM worker in an isolated git worktree
 glm-router benchmark         measure the Claude+GLM stack on built-in tasks
 glm-router usage             Z.ai quota snapshot + local benchmark totals
+glm-router runs              inspect recorded runs (show / logs / clean subcommands)
+glm-router watch [run-id]    attach to an active run and follow its progress
+glm-router dashboard         quota + active runs + recent runs
 glm-router mcp               optional MCP server registration (glm-mcp)
 glm-router project init      CLAUDE.md / AGENTS.md managed blocks (--dry-run supported)
 glm-router project remove
@@ -382,6 +485,10 @@ The key is never cached to disk.
 | The worker creates files but never runs the tests | Its Bash allowlist is empty. `glm-router config show` → `worker.allowedBash`; the default list covers common test commands |
 | `glm-*` not on PATH after install | Reopen the terminal; check `npm config get prefix` is on PATH |
 | `ERROR [MANAGED_BLOCK_CORRUPT]` | Fix the marker pair in the named file manually, then re-run |
+| Exit 41 `QUOTA_INSUFFICIENT` | Preflight refused the run (only with `routing.refuseOnCritical: true`). Wait for the window to reset, use `--model fast`, or `--force` |
+| Exit 42 `HANDOFF_REQUIRED` | Not a crash — the run handed off with a bundle. Read `handoff_path` in the stdout JSON and continue in the same worktree |
+| A run lists as FAILED with no summary | It died mid-run; `runs show <id>` rebuilds the summary from `events.jsonl`, `runs clean --orphans` reaps stale active entries |
+| `runs/` history grows large | `glm-router runs clean --older-than 30d`, or tune `history.retentionDays` / `history.maxRuns` |
 
 Run `glm-router doctor` (add `--network` to probe the Z.ai endpoint) for a full diagnosis.
 
@@ -418,8 +525,9 @@ npm test
 npm publish
 ```
 
-`prepublishOnly` runs build + tests. The package ships only `dist/`; the four binaries
-(`glm-router`, `glm-chat`, `glm-fast`, `glm-worker`, `glm-review`) are declared in `bin`.
+`prepublishOnly` runs build + tests. The package ships only `dist/`; the six binaries
+(`glm-router`, `glm-chat`, `glm-fast`, `glm-worker`, `glm-review`, `glm-mcp`) are declared
+in `bin`.
 
 ## License
 

package/dist/bin/glm-review.js

@@ -7,9 +7,11 @@ import { Errors, formatGlmError, GlmRouterError } from "../core/errors.js";
 import { isMainModule } from "../core/main-guard.js";
 import { logger, redact } from "../core/logging.js";
 import { applyProfile, extractProfileFlag } from "../core/profile.js";
+import { extractRoutingFlags } from "../core/routing-flags.js";
 import { readStdin, resolvePrompt } from "../core/prompt.js";
 import { spawnAgent } from "../core/process.js";
 import { resolveZaiApiKey } from "../core/zai-key.js";
+import { runInstrumented, shouldObserve } from "../runs/worker-run.js";
 /** Read-only review surface (spec §17) — no Edit, Write, or Bash. */
 export const REVIEW_TOOLS = "Read,Glob,Grep";
 /**
@@ -36,7 +38,10 @@ export function buildReviewArgs(prompt, config) {
  * discovery, duplicate detection, dependency inspection, and review.
  */
 export async function runReview(argv) {
-    const { rest, profile } = extractProfileFlag(argv);
+    const { rest: withoutProfile, profile } = extractProfileFlag(argv);
+    // Phase E flags come off before resolvePrompt: whatever is still in
+    // `rest` at that point becomes the prompt.
+    const { rest, model, force, refreshQuota } = extractRoutingFlags(withoutProfile);
     const prompt = await resolvePrompt(rest, readStdin, "glm-review");
     const config = applyProfile(loadConfig(), profile);
     const resolved = resolveZaiApiKey();
@@ -47,12 +52,32 @@ export async function runReview(argv) {
     const args = buildReviewArgs(prompt, config);
     const env = createGlmEnv(config, resolved.key);
     logger.debug(redact(`spawning ${claudePath} ${args.join(" ")}`, [resolved.key]));
-    return spawnAgent(claudePath, {
+    // v2 spec Phase D (C4): observe unless the caller opted out or already asked
+    // for a specific --output-format. The legacy path stays byte-identical.
+    if (!shouldObserve(args, process.env)) {
+        return spawnAgent(claudePath, {
+            args,
+            cwd: process.cwd(),
+            env,
+            interactive: false,
+        });
+    }
+    const observed = await runInstrumented({
+        kind: "review",
+        prompt,
         args,
+        claudePath,
+        config,
+        secrets: [resolved.key],
         cwd: process.cwd(),
         env,
-        interactive: false,
+        // Phase E; instrumented runs only, same as glm-worker.
+        zaiKey: resolved.key,
+        requestedModel: model,
+        force,
+        refreshQuota,
     });
+    return observed.code;
 }
 if (isMainModule(import.meta.url)) {
     runReview(process.argv.slice(2)).then((code) => process.exit(code), (error) => {

package/dist/bin/glm-worker.js

@@ -7,9 +7,11 @@ import { Errors, formatGlmError, GlmRouterError } from "../core/errors.js";
 import { isMainModule } from "../core/main-guard.js";
 import { logger, redact } from "../core/logging.js";
 import { applyProfile, extractProfileFlag } from "../core/profile.js";
+import { extractRoutingFlags } from "../core/routing-flags.js";
 import { resolvePrompt } from "../core/prompt.js";
 import { spawnAgent } from "../core/process.js";
 import { resolveZaiApiKey } from "../core/zai-key.js";
+import { runInstrumented, shouldObserve } from "../runs/worker-run.js";
 /** Worker tool surface (spec §16). */
 export const WORKER_TOOLS = "Read,Glob,Grep,Edit,Write,Bash";
 /** Same surface minus Bash, used when no Bash command is allowed. */
@@ -61,12 +63,15 @@ export function extractNoBashFlag(argv) {
 }
 /**
  * glm-worker (spec §15, §16): headless implementation worker.
- * Prompt priority: stdin → arguments → error. Never uses
+ * Prompt priority: arguments → stdin → error. Never uses
  * --dangerously-skip-permissions.
  */
 export async function runWorker(argv) {
     const { rest: withoutProfile, profile } = extractProfileFlag(argv);
-    const { rest, noBash } = extractNoBashFlag(withoutProfile);
+    const { rest: withoutBashFlag, noBash } = extractNoBashFlag(withoutProfile);
+    // Phase E flags come off last, and before resolvePrompt: everything still in
+    // `rest` at that point becomes the prompt.
+    const { rest, model, force, refreshQuota } = extractRoutingFlags(withoutBashFlag);
     const prompt = await resolvePrompt(rest);
     const loaded = applyProfile(loadConfig(), profile);
     const config = noBash
@@ -80,12 +85,33 @@ export async function runWorker(argv) {
     const args = buildWorkerArgs(prompt, config);
     const env = createGlmEnv(config, resolved.key);
     logger.debug(redact(`spawning ${claudePath} ${args.join(" ")}`, [resolved.key]));
-    return spawnAgent(claudePath, {
+    // v2 spec Phase D (C4): observe unless the caller opted out or already asked
+    // for a specific --output-format. The legacy path stays byte-identical.
+    if (!shouldObserve(args, process.env)) {
+        return spawnAgent(claudePath, {
+            args,
+            cwd: process.cwd(),
+            env,
+            interactive: false,
+        });
+    }
+    const observed = await runInstrumented({
+        kind: "worker",
+        prompt,
         args,
+        claudePath,
+        config,
+        secrets: [resolved.key],
         cwd: process.cwd(),
         env,
-        interactive: false,
+        // Phase E. The legacy path above never reaches here, so these flags apply
+        // to instrumented runs only — routing needs the event stream it observes.
+        zaiKey: resolved.key,
+        requestedModel: model,
+        force,
+        refreshQuota,
     });
+    return observed.code;
 }
 if (isMainModule(import.meta.url)) {
     runWorker(process.argv.slice(2)).then((code) => process.exit(code), (error) => {

package/dist/budget/estimator.js

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "../core/logging.js";
+import { costSamplesPath } from "../core/paths.js";
+/**
+ * Priority-ordered keyword table: the first row with a case-insensitive WHOLE
+ * WORD match wins, which is what makes "fix the failing test" a bugfix rather
+ * than a tests task — repair beats coverage when both match.
+ *
+ * Whole words, not substrings: a substring table reads "docker" as docs and
+ * "fixture" as bugfix, and this classifier is not cosmetic — it picks the cost
+ * row that decides `wouldRefuse`, which is the evidence D3 says 2.1's
+ * refuse-by-default decision will be argued from. Noise here becomes a wrong
+ * answer to "how often would the refusal have been wrong?". Word forms are
+ * therefore listed explicitly; an unlisted form falls through to a later row
+ * or to "other", and guessing low is the conservative failure.
+ */
+const KEYWORDS = [
+    [
+        "bugfix",
+        ["fix", "fixes", "fixed", "fixing", "bug", "bugs", "broken", "regression", "regressions",
+            "crash", "crashes", "crashing", "error", "errors", "defect", "defects", "repair"],
+    ],
+    ["tests", ["test", "tests", "testing", "spec", "specs", "coverage", "vitest", "jest", "pytest"]],
+    [
+        "docs",
+        ["doc", "docs", "document", "documents", "documentation", "docstring", "docstrings",
+            "readme", "comment", "comments", "changelog"],
+    ],
+    [
+        "refactor",
+        ["refactor", "refactors", "refactoring", "rename", "renames", "renaming", "extract",
+            "cleanup", "clean up", "restructure", "simplify", "migrate", "migration"],
+    ],
+    [
+        "explore",
+        ["explore", "investigate", "find", "search", "understand", "audit", "review", "analyze",
+            "analyse", "analysis"],
+    ],
+    [
+        "crud",
+        ["add", "create", "implement", "implements", "implementing", "endpoint", "endpoints",
+            "model", "models", "schema", "schemas", "crud", "build", "write"],
+    ],
+];
+/** Whole-word matcher for one row; `clean up` shows why a plain split() is not enough. */
+const MATCHERS = KEYWORDS.map(([kind, words]) => [
+    kind,
+    new RegExp(`\\b(?:${words.map(escapeRegExp).join("|")})\\b`, "i"),
+]);
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Deterministic keyword classifier — no model call, so preflight stays free,
+ * instant and reproducible. The prompt itself is never persisted here (C3);
+ * only the resulting kind reaches `cost-samples.jsonl`.
+ */
+export function classifyTask(prompt) {
+    for (const [kind, matcher] of MATCHERS) {
+        if (matcher.test(prompt)) {
+            return kind;
+        }
+    }
+    return "other";
+}
+/**
+ * Appends one JSON line to cost-samples.jsonl. Never throws: cost history is
+ * an optimization the next run can live without, and the run that earned the
+ * sample has already done its work by the time this is called.
+ */
+export function recordSample(home, sample) {
+    const file = costSamplesPath(home);
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify(sample) + "\n", "utf8");
+    }
+    catch (error) {
+        logger.debug(`estimator: could not record cost sample (${errorMessage(error)})`);
+    }
+}
+/**
+ * Reads the cost history. A missing file is "no history yet" and a malformed
+ * line is skipped, not fatal — the same tolerate-the-wreckage contract as the
+ * run store, because a truncated final line is normal crash wreckage.
+ */
+export function readSamples(home) {
+    let text;
+    try {
+        text = fs.readFileSync(costSamplesPath(home), "utf8");
+    }
+    catch {
+        return [];
+    }
+    const samples = [];
+    for (const [index, line] of text.split(/\r?\n/).entries()) {
+        if (line.trim() === "") {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            if (isSampleLike(parsed)) {
+                samples.push(parsed);
+            }
+            else {
+                logger.debug(`estimator: line ${index + 1} in ${costSamplesPath(home)} is not a sample`);
+            }
+        }
+        catch {
+            logger.debug(`estimator: skipping malformed line ${index + 1} in ${costSamplesPath(home)}`);
+        }
+    }
+    return samples;
+}
+/**
+ * True only when the quota delta between two snapshots can be attributed to
+ * exactly one run. All four rules must hold:
+ *
+ * - both snapshots have confidence "exact" or "cached" — an "unknown" side
+ *   makes the delta fiction;
+ * - fiveHour.resetAt is unchanged — a window reset mid-run makes the delta
+ *   meaningless (used drops to 0 and the difference goes negative);
+ * - the credit delta (end.used - start.used) is >= 0 — a negative delta
+ *   means a reset or a server correction, not a cost;
+ * - activeRunCount is exactly 1 — concurrent runs make credit attribution
+ *   meaningless, so those runs record nothing rather than a wrong number.
+ */
+export function isCleanMeasurement(input) {
+    const trusted = (confidence) => confidence === "exact" || confidence === "cached";
+    return (trusted(input.startSnapshot.confidence) &&
+        trusted(input.endSnapshot.confidence) &&
+        input.startSnapshot.fiveHour.resetAt === input.endSnapshot.fiveHour.resetAt &&
+        input.endSnapshot.fiveHour.used - input.startSnapshot.fiveHour.used >= 0 &&
+        input.activeRunCount === 1);
+}
+/**
+ * Main-model baseline, p50/p90 in plan credits. Transcribed from doc §13 and
+ * NEVER MEASURED on this stack — decision D3 keeps preflight refusal off in
+ * 2.0.0 precisely because this table is unmeasured; a wrongly-high row would
+ * refuse runs the quota could have afforded.
+ */
+const BASELINE_MAIN = {
+    explore: { p50: 15, p90: 28 },
+    crud: { p50: 42, p90: 66 },
+    tests: { p50: 30, p90: 50 },
+    docs: { p50: 12, p90: 22 },
+    refactor: { p50: 45, p90: 75 },
+    bugfix: { p50: 35, p90: 60 },
+    other: { p50: 35, p90: 60 },
+};
+/** Fast models are assumed to cost 40% of the main row, rounded. */
+const FAST_MODEL_RATIO = 0.4;
+/** History starts winning at this many samples; below it the noise would outrank the baseline. */
+const MIN_HISTORY_SAMPLES = 5;
+/**
+ * Estimated credits for one run of a task kind on a model. History wins when
+ * at least MIN_HISTORY_SAMPLES samples match BOTH the task kind and the model;
+ * otherwise the baseline table answers, with `samples: 0` and
+ * `source: "baseline"`.
+ *
+ * Main vs fast is decided by comparing `model` with the `fastModel`
+ * ARGUMENT — this module is deliberately config-free so it stays pure and
+ * testable, and callers (preflight, part 2) pass config.models.fast in.
+ */
+export function estimateCost(home, taskKind, model, fastModel) {
+    const credits = readSamples(home)
+        .filter((entry) => entry.taskKind === taskKind && entry.model === model)
+        .map((entry) => entry.credits);
+    if (credits.length >= MIN_HISTORY_SAMPLES) {
+        const sorted = [...credits].sort((a, b) => a - b);
+        return {
+            p50: nearestRank(sorted, 0.5),
+            p90: nearestRank(sorted, 0.9),
+            samples: sorted.length,
+            source: "history",
+        };
+    }
+    const main = BASELINE_MAIN[taskKind];
+    if (model === fastModel) {
+        return {
+            p50: Math.round(main.p50 * FAST_MODEL_RATIO),
+            p90: Math.round(main.p90 * FAST_MODEL_RATIO),
+            samples: 0,
+            source: "baseline",
+        };
+    }
+    return { p50: main.p50, p90: main.p90, samples: 0, source: "baseline" };
+}
+/**
+ * Nearest-rank percentile, deliberately NOT interpolation: sort ascending,
+ * take index ceil(p * n) - 1, clamped into [0, n-1]. For p90 with n = 5 that
+ * is literally the maximum sample. Interpolating would invent costs between
+ * samples that never happened; the rank is the honest, conservative reading.
+ * Do not "fix" this into interpolation later.
+ */
+function nearestRank(sortedAsc, p) {
+    const index = Math.min(sortedAsc.length - 1, Math.max(0, Math.ceil(p * sortedAsc.length) - 1));
+    return sortedAsc[index];
+}
+/**
+ * Same philosophy as the run store's isEventLike: "parses and has the fields
+ * estimateCost reads" (taskKind, model, credits). A line that parses but
+ * carries none of those cannot feed the estimator and is dropped; anything
+ * richer is history written by a future version and is kept.
+ */
+function isSampleLike(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.taskKind === "string" &&
+        typeof candidate.model === "string" &&
+        typeof candidate.credits === "number" &&
+        Number.isFinite(candidate.credits));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}