@shipispec/tsfix 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to `@shipispec/tsfix` are documented here. Format follows [K
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-05-19
+
+**Integration release.** Combines v0.6.0's library-aware error recovery with the multi-provider + telemetry work that landed on `main` between v0.5.0 and v0.6.0. The npm-published v0.6.0 was built from a stale local checkout and shipped without the Tier 2 (multi-provider) and Tier 3 (onLayerEvent + runFullStack) features that were already on `main`. v0.6.1 is the canonical "everything-since-0.5.0" release; users upgrading from v0.5.0 should jump straight to v0.6.1.
+
+### Added (Tier 3 — telemetry + unified entrypoint)
+- **`onLayerEvent?: (event: LayerEvent) => void`** callback option on `ValidationLoopOptions`, `RunMendLoopOptions`, and (new) `RunFullStackOptions`. Wires the `LayerEvent` type that's been published since v0.3.0 but never had a callback. Optional — undefined callback costs nothing.
+  - **Layer 1** emits one event per fixable-error attempt: `{layer: 1, errorCode, fixed, latencyMs, ts}`. `fixed: true` when a safe LSP fix landed; `fixed: false` when the fixer abstained (no candidate, ambiguous candidates, or zero-fix response).
+  - **Layer 2** emits one event per `runMendLoop` iteration: `{layer: 2, errorCode: <dominant code in iteration input>, fixed: <iteration cleared all errors>, latencyMs, ts}`. `costUsd` intentionally omitted from the per-event payload — callers can compute it from `result.layer2.totalInputTokens` + `totalOutputTokens` plus their own pricing.
+  - **Layer 4** emits one event per stub applied: `{layer: 4, errorCode: <parsed from "TSNNNN">, fixed: true, latencyMs: 0, ts}`. Multi-error coalesced stubs emit one event per `(stub × errorCode)` pair.
+- **`runFullStack(opts)`** — new top-level entrypoint that composes Layer 0/1 → Layer 2 (opt-in via `llm`) → Layer 4 (opt-in via `stubOnFailure`) and returns a unified `RunFullStackResult`. Callers who want "run the whole stack" no longer need to compose `runValidationLoop` + `runMendLoop` + (post-`runInProcessTsc` re-check) by hand. Library equivalent of the CLI's existing all-layers flow.
+- **`RunFullStackResult`** flat shape: `passed`, `errorsBefore`, `errorsAfterLayer1`, `errorsAfterAllLayers`, `layer1` (LSPFixer sub-result), `layer2` (RunMendLoopResult | null), `layer4` (`{stubsApplied: AppliedStub[]} | null`), `totalCostUsd`, `totalLatencyMs`, `remainingByCode`, `remainingByFile`. Matches the v0.3.0 roadmap sketch for the "unified result" type with cost + telemetry rolled in.
+- **10 new unit tests** in `src/runFullStack.test.ts` covering: clean workspace, Layer-1-only fix, unfixable-no-LLM, mocked-Layer-2 + cost math, unknown-model fallback, Layer-4 stubOnFailure path, per-error Layer-1 events, per-iteration Layer-2 events, per-stub Layer-4 events, undefined-callback smoke.
+
+### Added (multi-provider — Tier 2)
+- **OpenAI and Google providers** for Layer 2. `runMendLoop` and `mendSingleFile` now accept `llm.provider: "anthropic" | "openai" | "google"` (was: `"anthropic"` only). Each provider uses its corresponding `@ai-sdk/X` package via a small `buildLanguageModel` factory in `mendAgent.ts`. The factory's `switch` is exhaustive — TypeScript flags missing cases if a new provider is added to the `LLMProvider` union.
+- **`LLMProvider` type** exported from `src/index.ts`. Re-exportable for callers building their own CLI / pipeline integrations.
+- **CLI `--llm-provider <name>`** flag — `anthropic` (default, back-compat), `openai`, or `google`. Invalid values exit 2 with a clear message.
+- **Per-provider default models** when `--llm-model` is omitted: `claude-haiku-4-5` for anthropic, `gpt-5-mini` for openai, `gemini-2.5-flash` for google.
+- **Per-provider env var routing** in the CLI: `--llm-provider anthropic` → `ANTHROPIC_API_KEY`, `openai` → `OPENAI_API_KEY`, `google` → `GOOGLE_GENERATIVE_AI_API_KEY`. The error message names the exact missing var.
+- **Pricing table refreshed against current provider pricing pages (snapshot 2026-05-16):**
+  - **OpenAI:** `gpt-5-nano`, `gpt-5-mini`, `gpt-5`, `gpt-5.1`, `gpt-5.2`, `o3-mini`, `o4-mini`, `o3`. Default `--llm-model` for openai is `gpt-5-mini`.
+  - **Google:** `gemini-2.5-flash-lite`, `gemini-2.5-flash`, `gemini-2.5-pro`. Default for google is `gemini-2.5-flash`.
+  - **Anthropic (corrects v0.5.0 bugs):** `claude-haiku-4-5` was listed at `$0.80 / $4.00` — actual is **`$1.00 / $5.00`** (v0.5.0 carried the older Haiku 3.5 numbers). `claude-opus-4-7` was listed at `$15.00 / $75.00` — actual is **`$5.00 / $25.00`** (the 4.5 release dropped Opus pricing 3×; v0.5.0 carried the Opus 4.1 numbers). Now also lists `-sonnet-4-6`, `-opus-4-5`, `-opus-4-6`, `-opus-4-1` so callers pinning any 4.x model get accurate cost estimates.
+  - **Cost impact for v0.5.0 users:** `--llm-budget-usd` enforcement on `claude-haiku-4-5` was ~20% under-estimating actual spend; on `claude-opus-4-7` was ~3× over-estimating (your budget triggered earlier than it should have). Both fixed.
+  - Newer / unlisted models still fall back to cost=0 with a logger warning — `--llm-budget-usd` won't trigger for unpriced models.
+- **CLI JSON report** `layer2.provider` field added.
+- **CLI human report** Layer-2 line now shows `<provider>/<model>` instead of just `<model>`.
+- **2 new cache tests** in `benchmark/cache.test.ts` covering provider-discrimination in the cache key + back-compat default to `anthropic` when provider is omitted (preserves v0.5.0 cache entries on upgrade).
+- **5 new CLI tests** in `cli/run-stack.test.ts` covering `--help` listing all three providers + env-var names, invalid `--llm-provider` rejection, per-provider env-var routing, and the default-provider-is-anthropic back-compat case.
+
+### Changed
+- **`tsLanguageServiceFixer.ts`** internal loop now emits a `LayerEvent` per fixable error attempt when `onLayerEvent` is provided to `LSPFixerOptions`. Loop control unchanged; if the callback is undefined the only cost is one optional-chaining check per fix.
+- **`runMendLoop.ts`** emits per-iteration Layer-2 events and per-stub Layer-4 events when `onLayerEvent` is provided. New internal helpers `parseTsCode("TS2304") → 2304` and `dominantErrorCode(diags) → 2304` for event payload assembly.
+- **`LLMCall` type** input gains optional `provider?: LLMProvider`. Optional so v0.5.0 callers' `LLMCall` injections still type-check (their callbacks just ignore the new field).
+- **Cache key** at `benchmark/cache.ts` now includes provider: `sha256(systemBlock + " " + userBlock + " " + provider + " " + model)`. Provider defaults to `"anthropic"` when not passed → v0.5.0 cache entries remain valid for unchanged anthropic prompts.
+- **`scripts/build.mjs`** externalizes `@ai-sdk/openai` and `@ai-sdk/google` (in addition to `@ai-sdk/anthropic` and `ai`). Consumers who never invoke Layer 2 still don't load any AI SDK; consumers who do get whichever provider package they hit.
+- **Runtime dependencies added:** `@ai-sdk/openai@^3.0.64`, `@ai-sdk/google@^3.0.75`. Both are loaded lazily — the AI SDK package only loads when its corresponding provider is actually called.
+
+### Note on v0.6.0 npm tarball
+The `0.6.0` tarball on the npm registry was published from a stale local checkout that was based on `8921356 (chore: release v0.5.0)` and never fetched the `feat/multi-provider` and `feat/tier-3-onlayerevent` PRs that had already merged to `main`. As a result, npm `0.6.0` contains library-aware error recovery (see [0.6.0] below) but **not** multi-provider or onLayerEvent. v0.6.1 is the first release that combines all three feature sets. We did not unpublish `0.6.0` to avoid leaving an unpublish tombstone in the registry; please upgrade directly to `0.6.1` or later.
+
 ## [0.6.0] - 2026-05-19
 
 **Library-aware error recovery.** Layer 2 now auto-detects breaking-change hints for known libraries from your `package.json` and steers the LLM away from tsc's misleading quick-fixes when a library migration is the real cause. Plus a hardened type-context walk (no more crashes on rename cascades or branded types) and a meaningful set of security anti-patterns in the system prompt.
@@ -265,7 +306,8 @@ Initial public release. **Layers 0–1 only** (deterministic detection + auto-fi
 - Node `>=20.9.0` (matches VS Code Extension Host runtime)
 - TypeScript `>=5.0.0` (peer dep, must be installed in the consuming workspace)
 
-[Unreleased]: https://github.com/owgreen-dev/tsfix/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/owgreen-dev/tsfix/compare/v0.6.1...HEAD
+[0.6.1]: https://github.com/owgreen-dev/tsfix/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/owgreen-dev/tsfix/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/owgreen-dev/tsfix/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/owgreen-dev/tsfix/compare/v0.3.0...v0.4.0

package/README.md

@@ -5,7 +5,7 @@
 `@shipispec/tsfix` is what you reach for when you've just generated a few hundred files of TypeScript with an LLM and `tsc --noEmit` is screaming at you. It runs in layers:
 
 - **Layer 0/1** — Deterministic. Borrows the same TypeScript Language Service that powers VS Code's "Quick Fix" lightbulb and runs it as a CLI. Fixes typos, missing imports, and did-you-mean errors with no LLM, no network, no config.
-- **Layer 2** — Opt-in. A single-file LLM mend agent (Vercel AI SDK + Anthropic) that picks up what Layer 0 abstains on: TS2339 (property doesn't exist), TS7006 (implicit `any`), TS2741 (missing required prop), and other cases where the LSP can't statically derive the fix. Driven by **type-context injection** — when tsc says "Property 'foo' doesn't exist on type 'Bar'", tsfix resolves the `Bar` declaration via the TypeChecker and feeds its source to the model. As of v0.6.0, also **library-aware**: tsfix reads your `package.json` and injects breaking-change hints for known libraries (`vite-plugin-svgr`, `next`, `ai`, `drizzle-orm`) so the model picks the runtime-correct fix instead of tsc's misleading quick-fix.
+- **Layer 2** — Opt-in. A single-file LLM mend agent (Vercel AI SDK) that picks up what Layer 0 abstains on: TS2339 (property doesn't exist), TS7006 (implicit `any`), TS2741 (missing required prop), and other cases where the LSP can't statically derive the fix. Driven by **type-context injection** — when tsc says "Property 'foo' doesn't exist on type 'Bar'", tsfix resolves the `Bar` declaration via the TypeChecker and feeds its source to the model. **Multi-provider** (Anthropic / OpenAI / Google) via `--llm-provider`. As of v0.6.0, also **library-aware**: tsfix reads your `package.json` and injects breaking-change hints for known libraries (`vite-plugin-svgr`, `next`, `ai`, `drizzle-orm`) so the model picks the runtime-correct fix instead of tsc's misleading quick-fix.
 - **Layer 4** — Escape hatch. When Layer 2 can't resolve the last few errors, opt in to `// @ts-expect-error - tsfix: ...` directives that self-destruct once the underlying issue is fixed elsewhere. tsfix never leaves the workspace worse than it found it.
 
 Layer 2 only runs if you explicitly call its API or set `ANTHROPIC_API_KEY` and pass `--llm` to the CLI. The default `tsfix --workspace ...` CLI is still **Layer 0/1 only**.

package/dist/cli.js

@@ -192,7 +192,7 @@ var SAFE_FIX_NAMES = /* @__PURE__ */ new Set([
   // alternate spelling-fix name some TS versions emit
 ]);
 function runLSPFixerPass(opts) {
-  const { workspaceRoot, targetFiles, logger } = opts;
+  const { workspaceRoot, targetFiles, logger, onLayerEvent } = opts;
   const maxIterations = opts.maxIterations ?? 5;
   const dryRun = opts.dryRun ?? false;
   const tsconfigPath = path2.join(workspaceRoot, "tsconfig.json");
@@ -279,15 +279,37 @@ function runLSPFixerPass(opts) {
     lastErrorSignatures = signatures;
     let appliedThisIter = 0;
     for (const err of fixableErrors) {
+      const errStartMs = Date.now();
       const fixes = safeGetCodeFixes(service, err);
       if (!fixes || fixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const safeFixes = fixes.filter((f) => SAFE_FIX_NAMES.has(f.fixName));
       if (safeFixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       if (safeFixes.length > 1 && !fixesAreEquivalent(safeFixes)) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const fix = safeFixes[0];
@@ -298,6 +320,21 @@ function runLSPFixerPass(opts) {
         for (const change of fix.changes) {
           filesEdited.add(change.fileName);
         }
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: true,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
+      } else {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
       }
     }
     logger.info(
@@ -799,6 +836,8 @@ import * as fs6 from "node:fs";
 import * as path6 from "node:path";
 import { generateText } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
 
 // src/libraryMigrations.ts
 import * as fs5 from "node:fs";
@@ -982,10 +1021,24 @@ ${lines.join("\n")}
 
 Emit SEARCH/REPLACE blocks to resolve.`;
 }
-var defaultLLMCall = async ({ systemBlock, userBlock, model, apiKey }) => {
-  const anthropic = createAnthropic({ apiKey });
+function buildLanguageModel(provider, model, apiKey) {
+  switch (provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(model);
+    case "openai":
+      return createOpenAI({ apiKey })(model);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(model);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`unknown provider: ${_exhaustive}`);
+    }
+  }
+}
+var defaultLLMCall = async ({ systemBlock, userBlock, provider = "anthropic", model, apiKey }) => {
+  const llmModel = buildLanguageModel(provider, model, apiKey);
   const result = await generateText({
-    model: anthropic(model),
+    model: llmModel,
     system: systemBlock,
     messages: [{ role: "user", content: userBlock }]
   });
@@ -1007,6 +1060,7 @@ async function mendSingleFile(opts) {
   const llmResult = await _callLLM({
     systemBlock,
     userBlock,
+    provider: llm.provider,
     model: llm.model,
     apiKey: llm.apiKey
   });
@@ -1211,8 +1265,35 @@ function refreshDiagnostics(workspaceRoot, files) {
   });
   return result.diagnostics.filter((d) => d.category === "error");
 }
+function parseTsCode(code) {
+  const m = /^TS(\d+)$/.exec(code);
+  return m ? parseInt(m[1], 10) : 0;
+}
+function dominantErrorCode(diags) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of diags) {
+    counts.set(d.code, (counts.get(d.code) ?? 0) + 1);
+  }
+  let bestCode = "";
+  let bestCount = 0;
+  for (const [code, count] of counts) {
+    if (count > bestCount) {
+      bestCount = count;
+      bestCode = code;
+    }
+  }
+  return parseTsCode(bestCode);
+}
 async function runMendLoop(opts) {
-  const { context: rawContext, llm, maxIterations = 3, dryRun = false, stubOnFailure = false, _callLLM } = opts;
+  const {
+    context: rawContext,
+    llm,
+    maxIterations = 3,
+    dryRun = false,
+    stubOnFailure = false,
+    onLayerEvent,
+    _callLLM
+  } = opts;
   const startMs = Date.now();
   const context = rawContext.libraryMigrations === void 0 ? { ...rawContext, libraryMigrations: detectLibraryMigrations(rawContext.workspaceRoot) } : rawContext;
   const diagnosticsBefore = context.diagnostics.filter((d) => d.category === "error");
@@ -1263,6 +1344,13 @@ async function runMendLoop(opts) {
       latencyMs: mend.latencyMs,
       rawResponse: mend.rawResponse
     });
+    onLayerEvent?.({
+      layer: 2,
+      errorCode: dominantErrorCode(currentDiags),
+      fixed: newDiags.length === 0,
+      latencyMs: mend.latencyMs,
+      ts: Date.now()
+    });
     if (dryRun) {
       currentDiags = newDiags;
       stopReason = "maxIterations";
@@ -1293,6 +1381,20 @@ async function runMendLoop(opts) {
       diagnostics: currentDiags
     });
     stubs = stubResult.stubsApplied;
+    if (onLayerEvent) {
+      const stubTs = Date.now();
+      for (const stub of stubResult.stubsApplied) {
+        for (const code of stub.codes) {
+          onLayerEvent({
+            layer: 4,
+            errorCode: parseTsCode(code),
+            fixed: true,
+            latencyMs: 0,
+            ts: stubTs
+          });
+        }
+      }
+    }
     const postStubDiags = refreshDiagnostics(context.workspaceRoot, filesInScope);
     if (postStubDiags.length === 0) {
       stopReason = "stubbed";
@@ -1369,7 +1471,13 @@ function runValidationLoop(opts) {
     iterations: 0
   };
   if (errorsBefore > 0 && !skipLSPFixer) {
-    const lsp = runLSPFixerPass({ workspaceRoot, targetFiles, logger, dryRun });
+    const lsp = runLSPFixerPass({
+      workspaceRoot,
+      targetFiles,
+      logger,
+      dryRun,
+      onLayerEvent: opts.onLayerEvent
+    });
     lspFixer = {
       ran: true,
       fixesApplied: lsp.fixesApplied,
@@ -1402,16 +1510,59 @@ function runValidationLoop(opts) {
 }
 
 // cli/run-stack.ts
-var ANTHROPIC_PRICING = {
-  "claude-haiku-4-5": { input: 0.8, output: 4 },
-  "claude-sonnet-4-5": { input: 3, output: 15 },
-  "claude-opus-4-7": { input: 15, output: 75 }
+var PRICING = {
+  anthropic: {
+    // All 4.5+ models share the same tier (the 4.5 release brought a
+    // significant price drop on Opus). 4.1 retains the older Opus tier.
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-opus-4-5": { input: 5, output: 25 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-opus-4-7": { input: 5, output: 25 },
+    "claude-opus-4-1": { input: 15, output: 75 }
+  },
+  openai: {
+    // Mini / nano tiers — well-matched to TypeScript repair (small
+    // context, structured output). Default model uses one of these.
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    // gpt-5 flagship + recent point releases (all $1.25 / $10).
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    // Reasoning models — sometimes better at semantic repair, more expensive.
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 }
+  },
+  google: {
+    // Lite < flash < pro, matching the haiku/sonnet/opus mental model.
+    "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+    // Standard tier (≤200k tokens). 2.5-pro doubles to $2.50/$15.00 above
+    // 200k — not modeled here since our prompts are well below that.
+    "gemini-2.5-pro": { input: 1.25, output: 10 }
+  }
 };
-function estimateCostUsd(model, inputTokens, outputTokens) {
-  const p = ANTHROPIC_PRICING[model];
+function estimateCostUsd(provider, model, inputTokens, outputTokens) {
+  const p = PRICING[provider]?.[model];
   if (!p) return 0;
   return (inputTokens * p.input + outputTokens * p.output) / 1e6;
 }
+var ENV_KEY_BY_PROVIDER = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY"
+};
+var DEFAULT_MODEL_BY_PROVIDER = {
+  anthropic: "claude-haiku-4-5",
+  openai: "gpt-5-mini",
+  google: "gemini-2.5-flash"
+};
+function isLLMProvider(s) {
+  return s === "anthropic" || s === "openai" || s === "google";
+}
 function parseArgs(argv) {
   const args = {
     workspace: "",
@@ -1421,7 +1572,11 @@ function parseArgs(argv) {
     files: void 0,
     verbose: false,
     llm: false,
-    llmModel: "claude-haiku-4-5",
+    llmProvider: "anthropic",
+    // llmModel default depends on provider — we set it AFTER parsing so
+    // `--llm-provider openai` without `--llm-model` picks gpt-4o-mini, etc.
+    // An empty string here means "use the provider's default".
+    llmModel: "",
     llmMaxIterations: 3,
     llmBudgetUsd: void 0,
     noLibraryHints: false
@@ -1442,6 +1597,13 @@ function parseArgs(argv) {
       args.verbose = true;
     } else if (a === "--llm") {
       args.llm = true;
+    } else if (a === "--llm-provider") {
+      const p = argv[++i] ?? "";
+      if (!isLLMProvider(p)) {
+        console.error(`error: --llm-provider expects one of: anthropic, openai, google. Got '${p}'`);
+        process.exit(2);
+      }
+      args.llmProvider = p;
     } else if (a === "--llm-model") {
       args.llmModel = argv[++i] ?? args.llmModel;
     } else if (a === "--llm-max-iterations") {
@@ -1470,6 +1632,9 @@ function parseArgs(argv) {
     printHelp();
     process.exit(2);
   }
+  if (args.llmModel === "") {
+    args.llmModel = DEFAULT_MODEL_BY_PROVIDER[args.llmProvider];
+  }
   return args;
 }
 function printHelp() {
@@ -1485,12 +1650,23 @@ Layer 0/1 (default \u2014 deterministic, no network):
   --verbose, -v               Stream layer logs to stderr
   --help, -h                  Show this help
 
-Layer 2 (opt-in \u2014 single-file LLM mend via Anthropic):
+Layer 2 (opt-in \u2014 single-file LLM mend):
   --llm                       Enable Layer 2 on errors that survive Layer 0/1
-  --llm-model <name>          Anthropic model (default: claude-haiku-4-5)
-                              Known-priced models: claude-haiku-4-5,
-                              claude-sonnet-4-5, claude-opus-4-7.
-                              Cost estimate is 0 for unknown models.
+  --llm-provider <name>       anthropic | openai | google   (default: anthropic)
+  --llm-model <name>          Model name. Defaults per provider:
+                                anthropic \u2192 claude-haiku-4-5
+                                openai    \u2192 gpt-5-mini
+                                google    \u2192 gemini-2.5-flash
+                              Known-priced models per provider:
+                                anthropic: claude-haiku-4-5, -sonnet-4-5,
+                                           -sonnet-4-6, -opus-4-5, -opus-4-6,
+                                           -opus-4-7, -opus-4-1
+                                openai:    gpt-5-nano, gpt-5-mini, gpt-5,
+                                           gpt-5.1, gpt-5.2, o3-mini, o4-mini, o3
+                                google:    gemini-2.5-flash-lite, gemini-2.5-flash,
+                                           gemini-2.5-pro
+                              Cost estimate is 0 for unlisted models (the
+                              warning suggests pinning a listed one).
   --llm-max-iterations <N>    Cap on LLM retries (default: 3)
   --llm-budget-usd <amount>   Soft cost cap. Exits with code 3 if exceeded.
   --no-library-hints          Disable auto-detection of library breaking-change
@@ -1500,7 +1676,10 @@ Layer 2 (opt-in \u2014 single-file LLM mend via Anthropic):
                               tsfix injects hints into Layer 2's prompt + skips
                               Layer 0/1 (whose quick-fix would conflict).
 
-Layer 2 requires ANTHROPIC_API_KEY in the environment.
+Layer 2 requires the provider's API key in env:
+  anthropic \u2192 ANTHROPIC_API_KEY
+  openai    \u2192 OPENAI_API_KEY
+  google    \u2192 GOOGLE_GENERATIVE_AI_API_KEY
 
 Exit codes:
   0  no errors after stack
@@ -1551,7 +1730,7 @@ TSC Defense Stack \u2014 ${r.workspace}${r.dryRun ? " (dry-run)" : ""}
       `  Layer 2 (LLM): ${l2.errorsBefore} \u2192 ${l2.errorsAfter} errors  ${l2.iterations}\xD7 iter  ${l2.totalInputTokens}\u2192${l2.totalOutputTokens} tokens  $${l2.totalCostUsd.toFixed(4)} ${l2.budgetExceeded ? "\u26A0\uFE0F  budget exceeded" : ""}
 `
     );
-    w.write(`                 model=${l2.model} \xB7 stopReason=${l2.stopReason}
+    w.write(`                 ${l2.provider}/${l2.model} \xB7 stopReason=${l2.stopReason}
 `);
   }
   w.write(`  errors after:  ${r.errorsAfter}
@@ -1622,14 +1801,15 @@ async function main() {
       console.error("error: --llm and --dry-run are mutually exclusive (Layer 2 writes patches to disk)");
       return 2;
     }
-    const apiKey = process.env.ANTHROPIC_API_KEY;
+    const envKeyName = ENV_KEY_BY_PROVIDER[args.llmProvider];
+    const apiKey = process.env[envKeyName];
     if (!apiKey) {
-      console.error("error: --llm requires ANTHROPIC_API_KEY in the environment");
+      console.error(`error: --llm with provider '${args.llmProvider}' requires ${envKeyName} in the environment`);
       return 2;
     }
-    if (!ANTHROPIC_PRICING[args.llmModel]) {
+    if (!PRICING[args.llmProvider]?.[args.llmModel]) {
       logger.warn(
-        `unknown model '${args.llmModel}' \u2014 cost estimates will be 0; budget cap will not trigger`
+        `unknown model '${args.llmProvider}/${args.llmModel}' \u2014 cost estimates will be 0; budget cap will not trigger`
       );
     }
     const errorDiags = loop.diagnostics.filter((d) => d.category === "error");
@@ -1645,11 +1825,12 @@ async function main() {
     const layer2Start = Date.now();
     const mend = await runMendLoop({
       context,
-      llm: { provider: "anthropic", model: args.llmModel, apiKey },
+      llm: { provider: args.llmProvider, model: args.llmModel, apiKey },
       maxIterations: args.llmMaxIterations
     });
     void layer2Start;
     const totalCostUsd = estimateCostUsd(
+      args.llmProvider,
       args.llmModel,
       mend.totalInputTokens,
       mend.totalOutputTokens
@@ -1665,6 +1846,7 @@ async function main() {
       totalOutputTokens: mend.totalOutputTokens,
       totalCostUsd,
       budgetExceeded,
+      provider: args.llmProvider,
       model: args.llmModel
     };
     const post = runInProcessTsc({

package/dist/index.d.ts

@@ -82,6 +82,12 @@ export interface ValidationLoopOptions {
     dryRun?: boolean;
     /** Default: a no-op logger. Pass your own to capture layer events. */
     logger?: Logger;
+    /**
+     * Per-error telemetry callback for Layer 1 (LSP fixer). Fires once per
+     * fixable error with `{layer: 1, errorCode, fixed, latencyMs, ts}`. Optional;
+     * undefined callback costs nothing. See `LayerEvent`.
+     */
+    onLayerEvent?: (event: LayerEvent) => void;
 }
 export interface ValidationLoopResult {
     passed: boolean;
@@ -203,10 +209,88 @@ export type { TypeContextOptions, TypeContext } from "./typeContext.js";
 export { parseEditBlocks, applySingleBlock, applyEditBlocks } from "./applyEditBlock.js";
 export type { EditBlock, ApplyEditBlocksOptions, ApplyResult, SingleBlockResult, } from "./applyEditBlock.js";
 export { mendSingleFile } from "./mendAgent.js";
-export type { MendSingleFileOptions, MendSingleFileResult, LLMCall } from "./mendAgent.js";
+export type { MendSingleFileOptions, MendSingleFileResult, LLMCall, LLMProvider, } from "./mendAgent.js";
 export { runMendLoop } from "./runMendLoop.js";
 export type { RunMendLoopOptions, RunMendLoopResult, MendLoopIteration, StopReason, } from "./runMendLoop.js";
 export { stubAndContinue } from "./stubAndContinue.js";
 export type { StubAndContinueOptions, StubAndContinueResult, AppliedStub, SkippedStub, } from "./stubAndContinue.js";
 export { BUILT_IN_LIBRARY_MIGRATIONS, detectLibraryMigrations, formatLibraryMigrationsBlock, formatLibraryMigrationsTaskDescription, } from "./libraryMigrations.js";
 export type { LibraryMigrationHint } from "./libraryMigrations.js";
+import { type RunMendLoopResult } from "./runMendLoop.js";
+import type { AppliedStub } from "./stubAndContinue.js";
+import type { LLMProvider } from "./mendAgent.js";
+export interface RunFullStackOptions {
+    /** Absolute path to the workspace (must contain `tsconfig.json`). */
+    workspaceRoot: string;
+    /** Files to scope to. If omitted, all `.ts`/`.tsx` files under workspaceRoot. */
+    targetFiles?: string[];
+    /** Skip Layer 0/1 LSP auto-fixer. Default false. */
+    skipLSPFixer?: boolean;
+    /**
+     * Layer 2 config. If omitted, the loop stops after Layer 0/1 (matches
+     * `runValidationLoop` behavior — no LLM calls).
+     */
+    llm?: {
+        provider: LLMProvider;
+        model: string;
+        apiKey: string;
+        maxIterations?: number;
+    };
+    /**
+     * After Layer 2 (if any), insert `// @ts-expect-error - tsfix: …` above
+     * each unresolved error site so tsc exits 0. Opt-in. Default false.
+     */
+    stubOnFailure?: boolean;
+    /**
+     * Run all layers in memory; report counts but don't write. Default false.
+     * Layer 2 is auto-skipped under dryRun (it writes patches; would be a
+     * no-op).
+     */
+    dryRun?: boolean;
+    /** Logger. Default no-op. */
+    logger?: Logger;
+    /** Per-layer telemetry stream. Forwarded to Layer 1, 2, 4. */
+    onLayerEvent?: (event: LayerEvent) => void;
+    /** @internal — LLM call override. Tests inject a fake; real callers leave it. */
+    _callLLM?: import("./mendAgent.js").LLMCall;
+}
+export interface RunFullStackResult {
+    /** True if `errorsAfterAllLayers === 0`. */
+    passed: boolean;
+    /** Errors detected before any fix attempt. */
+    errorsBefore: number;
+    /** Errors remaining after Layer 0/1 (before Layer 2 + 4). */
+    errorsAfterLayer1: number;
+    /** Errors remaining after every layer that ran. */
+    errorsAfterAllLayers: number;
+    /** Per-layer sub-results. `layer2` is null when `llm` was omitted; `layer4` is null when `stubOnFailure` was false (or had no candidates). */
+    layer1: ValidationLoopResult["lspFixer"];
+    layer2: RunMendLoopResult | null;
+    layer4: {
+        stubsApplied: AppliedStub[];
+    } | null;
+    /** USD spent on Layer 2. 0 when Layer 2 didn't run. */
+    totalCostUsd: number;
+    /** Wall-clock total across all layers. */
+    totalLatencyMs: number;
+    /** Remaining diagnostics, grouped by TS code (e.g. `{TS2339: 3}`). */
+    remainingByCode: Record<string, number>;
+    /** Remaining diagnostics, grouped by file path (relative to workspaceRoot). */
+    remainingByFile: Record<string, number>;
+}
+/**
+ * Run the full tsfix stack (Layer 0/1 → Layer 2 → Layer 4) end-to-end.
+ *
+ * @example
+ * ```ts
+ * const result = await runFullStack({
+ *   workspaceRoot: "/path/to/project",
+ *   llm: { provider: "anthropic", model: "claude-haiku-4-5", apiKey: KEY },
+ *   stubOnFailure: true,
+ *   onLayerEvent: (e) => console.log(e),
+ * });
+ * if (!result.passed) { ... }
+ * console.log(`Spent $${result.totalCostUsd.toFixed(4)}`);
+ * ```
+ */
+export declare function runFullStack(opts: RunFullStackOptions): Promise<RunFullStackResult>;

package/dist/index.js

@@ -189,7 +189,7 @@ var SAFE_FIX_NAMES = /* @__PURE__ */ new Set([
   // alternate spelling-fix name some TS versions emit
 ]);
 function runLSPFixerPass(opts) {
-  const { workspaceRoot, targetFiles, logger } = opts;
+  const { workspaceRoot, targetFiles, logger, onLayerEvent } = opts;
   const maxIterations = opts.maxIterations ?? 5;
   const dryRun = opts.dryRun ?? false;
   const tsconfigPath = path2.join(workspaceRoot, "tsconfig.json");
@@ -276,15 +276,37 @@ function runLSPFixerPass(opts) {
     lastErrorSignatures = signatures;
     let appliedThisIter = 0;
     for (const err of fixableErrors) {
+      const errStartMs = Date.now();
       const fixes = safeGetCodeFixes(service, err);
       if (!fixes || fixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const safeFixes = fixes.filter((f) => SAFE_FIX_NAMES.has(f.fixName));
       if (safeFixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       if (safeFixes.length > 1 && !fixesAreEquivalent(safeFixes)) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const fix = safeFixes[0];
@@ -295,6 +317,21 @@ function runLSPFixerPass(opts) {
         for (const change of fix.changes) {
           filesEdited.add(change.fileName);
         }
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: true,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
+      } else {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
       }
     }
     logger.info(
@@ -804,6 +841,8 @@ import * as fs6 from "node:fs";
 import * as path6 from "node:path";
 import { generateText } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
 
 // src/libraryMigrations.ts
 import * as fs5 from "node:fs";
@@ -987,10 +1026,24 @@ ${lines.join("\n")}
 
 Emit SEARCH/REPLACE blocks to resolve.`;
 }
-var defaultLLMCall = async ({ systemBlock, userBlock, model, apiKey }) => {
-  const anthropic = createAnthropic({ apiKey });
+function buildLanguageModel(provider, model, apiKey) {
+  switch (provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(model);
+    case "openai":
+      return createOpenAI({ apiKey })(model);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(model);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`unknown provider: ${_exhaustive}`);
+    }
+  }
+}
+var defaultLLMCall = async ({ systemBlock, userBlock, provider = "anthropic", model, apiKey }) => {
+  const llmModel = buildLanguageModel(provider, model, apiKey);
   const result = await generateText({
-    model: anthropic(model),
+    model: llmModel,
     system: systemBlock,
     messages: [{ role: "user", content: userBlock }]
   });
@@ -1012,6 +1065,7 @@ async function mendSingleFile(opts) {
   const llmResult = await _callLLM({
     systemBlock,
     userBlock,
+    provider: llm.provider,
     model: llm.model,
     apiKey: llm.apiKey
   });
@@ -1216,8 +1270,35 @@ function refreshDiagnostics(workspaceRoot, files) {
   });
   return result.diagnostics.filter((d) => d.category === "error");
 }
+function parseTsCode(code) {
+  const m = /^TS(\d+)$/.exec(code);
+  return m ? parseInt(m[1], 10) : 0;
+}
+function dominantErrorCode(diags) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of diags) {
+    counts.set(d.code, (counts.get(d.code) ?? 0) + 1);
+  }
+  let bestCode = "";
+  let bestCount = 0;
+  for (const [code, count] of counts) {
+    if (count > bestCount) {
+      bestCount = count;
+      bestCode = code;
+    }
+  }
+  return parseTsCode(bestCode);
+}
 async function runMendLoop(opts) {
-  const { context: rawContext, llm, maxIterations = 3, dryRun = false, stubOnFailure = false, _callLLM } = opts;
+  const {
+    context: rawContext,
+    llm,
+    maxIterations = 3,
+    dryRun = false,
+    stubOnFailure = false,
+    onLayerEvent,
+    _callLLM
+  } = opts;
   const startMs = Date.now();
   const context = rawContext.libraryMigrations === void 0 ? { ...rawContext, libraryMigrations: detectLibraryMigrations(rawContext.workspaceRoot) } : rawContext;
   const diagnosticsBefore = context.diagnostics.filter((d) => d.category === "error");
@@ -1268,6 +1349,13 @@ async function runMendLoop(opts) {
       latencyMs: mend.latencyMs,
       rawResponse: mend.rawResponse
     });
+    onLayerEvent?.({
+      layer: 2,
+      errorCode: dominantErrorCode(currentDiags),
+      fixed: newDiags.length === 0,
+      latencyMs: mend.latencyMs,
+      ts: Date.now()
+    });
     if (dryRun) {
       currentDiags = newDiags;
       stopReason = "maxIterations";
@@ -1298,6 +1386,20 @@ async function runMendLoop(opts) {
       diagnostics: currentDiags
     });
     stubs = stubResult.stubsApplied;
+    if (onLayerEvent) {
+      const stubTs = Date.now();
+      for (const stub of stubResult.stubsApplied) {
+        for (const code of stub.codes) {
+          onLayerEvent({
+            layer: 4,
+            errorCode: parseTsCode(code),
+            fixed: true,
+            latencyMs: 0,
+            ts: stubTs
+          });
+        }
+      }
+    }
     const postStubDiags = refreshDiagnostics(context.workspaceRoot, filesInScope);
     if (postStubDiags.length === 0) {
       stopReason = "stubbed";
@@ -1374,7 +1476,13 @@ function runValidationLoop(opts) {
     iterations: 0
   };
   if (errorsBefore > 0 && !skipLSPFixer) {
-    const lsp = runLSPFixerPass({ workspaceRoot, targetFiles, logger, dryRun });
+    const lsp = runLSPFixerPass({
+      workspaceRoot,
+      targetFiles,
+      logger,
+      dryRun,
+      onLayerEvent: opts.onLayerEvent
+    });
     lspFixer = {
       ran: true,
       fixesApplied: lsp.fixesApplied,
@@ -1405,6 +1513,100 @@ function runValidationLoop(opts) {
     elapsedMs: Date.now() - startMs
   };
 }
+var PRICING = {
+  anthropic: {
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-opus-4-5": { input: 5, output: 25 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-opus-4-7": { input: 5, output: 25 },
+    "claude-opus-4-1": { input: 15, output: 75 }
+  },
+  openai: {
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 }
+  },
+  google: {
+    "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+    "gemini-2.5-pro": { input: 1.25, output: 10 }
+  }
+};
+function costUsd(provider, model, inputTokens, outputTokens) {
+  const p = PRICING[provider]?.[model];
+  if (!p) return 0;
+  return (inputTokens * p.input + outputTokens * p.output) / 1e6;
+}
+async function runFullStack(opts) {
+  const startMs = Date.now();
+  const { workspaceRoot, llm, stubOnFailure = false, dryRun = false, onLayerEvent } = opts;
+  const layer1 = runValidationLoop({
+    workspaceRoot,
+    targetFiles: opts.targetFiles,
+    skipLSPFixer: opts.skipLSPFixer,
+    dryRun,
+    logger: opts.logger,
+    onLayerEvent
+  });
+  let layer2 = null;
+  let layer4 = null;
+  let totalCostUsd = 0;
+  let finalDiagnostics = layer1.diagnostics;
+  const shouldRunLayer2 = llm && !dryRun && layer1.errorsAfter > 0;
+  if (shouldRunLayer2) {
+    const errorDiags = layer1.diagnostics.filter((d) => d.category === "error");
+    layer2 = await runMendLoop({
+      context: {
+        workspaceRoot,
+        diagnostics: errorDiags,
+        erroredFiles: Array.from(new Set(errorDiags.map((d) => d.file)))
+      },
+      llm: { provider: llm.provider, model: llm.model, apiKey: llm.apiKey },
+      maxIterations: llm.maxIterations,
+      stubOnFailure,
+      onLayerEvent,
+      _callLLM: opts._callLLM
+    });
+    totalCostUsd = costUsd(llm.provider, llm.model, layer2.totalInputTokens, layer2.totalOutputTokens);
+    if (layer2.stubs && layer2.stubs.length > 0) {
+      layer4 = { stubsApplied: layer2.stubs };
+    }
+    resetInProcessTscCache();
+    const post = runInProcessTsc({
+      workspaceRoot,
+      generatedFiles: opts.targetFiles ?? discoverTsFiles(workspaceRoot),
+      logger: opts.logger ?? noopLogger3
+    });
+    finalDiagnostics = post.diagnostics;
+  }
+  const finalErrorDiags = finalDiagnostics.filter((d) => d.category === "error");
+  const remainingByCode = {};
+  const remainingByFile = {};
+  for (const d of finalErrorDiags) {
+    remainingByCode[d.code] = (remainingByCode[d.code] ?? 0) + 1;
+    remainingByFile[d.file] = (remainingByFile[d.file] ?? 0) + 1;
+  }
+  return {
+    passed: finalErrorDiags.length === 0,
+    errorsBefore: layer1.errorsBefore,
+    errorsAfterLayer1: layer1.errorsAfter,
+    errorsAfterAllLayers: finalErrorDiags.length,
+    layer1: layer1.lspFixer,
+    layer2,
+    layer4,
+    totalCostUsd,
+    totalLatencyMs: Date.now() - startMs,
+    remainingByCode,
+    remainingByFile
+  };
+}
 export {
   BUILT_IN_LIBRARY_MIGRATIONS,
   applyEditBlocks,
@@ -1421,6 +1623,7 @@ export {
   resetInProcessTscCache,
   resetLSPFixerCache,
   resetTypeContextCache,
+  runFullStack,
   runInProcessTsc,
   runLSPFixerPass,
   runMendLoop,

package/dist/types/index.d.ts

@@ -82,6 +82,12 @@ export interface ValidationLoopOptions {
     dryRun?: boolean;
     /** Default: a no-op logger. Pass your own to capture layer events. */
     logger?: Logger;
+    /**
+     * Per-error telemetry callback for Layer 1 (LSP fixer). Fires once per
+     * fixable error with `{layer: 1, errorCode, fixed, latencyMs, ts}`. Optional;
+     * undefined callback costs nothing. See `LayerEvent`.
+     */
+    onLayerEvent?: (event: LayerEvent) => void;
 }
 export interface ValidationLoopResult {
     passed: boolean;
@@ -203,10 +209,88 @@ export type { TypeContextOptions, TypeContext } from "./typeContext.js";
 export { parseEditBlocks, applySingleBlock, applyEditBlocks } from "./applyEditBlock.js";
 export type { EditBlock, ApplyEditBlocksOptions, ApplyResult, SingleBlockResult, } from "./applyEditBlock.js";
 export { mendSingleFile } from "./mendAgent.js";
-export type { MendSingleFileOptions, MendSingleFileResult, LLMCall } from "./mendAgent.js";
+export type { MendSingleFileOptions, MendSingleFileResult, LLMCall, LLMProvider, } from "./mendAgent.js";
 export { runMendLoop } from "./runMendLoop.js";
 export type { RunMendLoopOptions, RunMendLoopResult, MendLoopIteration, StopReason, } from "./runMendLoop.js";
 export { stubAndContinue } from "./stubAndContinue.js";
 export type { StubAndContinueOptions, StubAndContinueResult, AppliedStub, SkippedStub, } from "./stubAndContinue.js";
 export { BUILT_IN_LIBRARY_MIGRATIONS, detectLibraryMigrations, formatLibraryMigrationsBlock, formatLibraryMigrationsTaskDescription, } from "./libraryMigrations.js";
 export type { LibraryMigrationHint } from "./libraryMigrations.js";
+import { type RunMendLoopResult } from "./runMendLoop.js";
+import type { AppliedStub } from "./stubAndContinue.js";
+import type { LLMProvider } from "./mendAgent.js";
+export interface RunFullStackOptions {
+    /** Absolute path to the workspace (must contain `tsconfig.json`). */
+    workspaceRoot: string;
+    /** Files to scope to. If omitted, all `.ts`/`.tsx` files under workspaceRoot. */
+    targetFiles?: string[];
+    /** Skip Layer 0/1 LSP auto-fixer. Default false. */
+    skipLSPFixer?: boolean;
+    /**
+     * Layer 2 config. If omitted, the loop stops after Layer 0/1 (matches
+     * `runValidationLoop` behavior — no LLM calls).
+     */
+    llm?: {
+        provider: LLMProvider;
+        model: string;
+        apiKey: string;
+        maxIterations?: number;
+    };
+    /**
+     * After Layer 2 (if any), insert `// @ts-expect-error - tsfix: …` above
+     * each unresolved error site so tsc exits 0. Opt-in. Default false.
+     */
+    stubOnFailure?: boolean;
+    /**
+     * Run all layers in memory; report counts but don't write. Default false.
+     * Layer 2 is auto-skipped under dryRun (it writes patches; would be a
+     * no-op).
+     */
+    dryRun?: boolean;
+    /** Logger. Default no-op. */
+    logger?: Logger;
+    /** Per-layer telemetry stream. Forwarded to Layer 1, 2, 4. */
+    onLayerEvent?: (event: LayerEvent) => void;
+    /** @internal — LLM call override. Tests inject a fake; real callers leave it. */
+    _callLLM?: import("./mendAgent.js").LLMCall;
+}
+export interface RunFullStackResult {
+    /** True if `errorsAfterAllLayers === 0`. */
+    passed: boolean;
+    /** Errors detected before any fix attempt. */
+    errorsBefore: number;
+    /** Errors remaining after Layer 0/1 (before Layer 2 + 4). */
+    errorsAfterLayer1: number;
+    /** Errors remaining after every layer that ran. */
+    errorsAfterAllLayers: number;
+    /** Per-layer sub-results. `layer2` is null when `llm` was omitted; `layer4` is null when `stubOnFailure` was false (or had no candidates). */
+    layer1: ValidationLoopResult["lspFixer"];
+    layer2: RunMendLoopResult | null;
+    layer4: {
+        stubsApplied: AppliedStub[];
+    } | null;
+    /** USD spent on Layer 2. 0 when Layer 2 didn't run. */
+    totalCostUsd: number;
+    /** Wall-clock total across all layers. */
+    totalLatencyMs: number;
+    /** Remaining diagnostics, grouped by TS code (e.g. `{TS2339: 3}`). */
+    remainingByCode: Record<string, number>;
+    /** Remaining diagnostics, grouped by file path (relative to workspaceRoot). */
+    remainingByFile: Record<string, number>;
+}
+/**
+ * Run the full tsfix stack (Layer 0/1 → Layer 2 → Layer 4) end-to-end.
+ *
+ * @example
+ * ```ts
+ * const result = await runFullStack({
+ *   workspaceRoot: "/path/to/project",
+ *   llm: { provider: "anthropic", model: "claude-haiku-4-5", apiKey: KEY },
+ *   stubOnFailure: true,
+ *   onLayerEvent: (e) => console.log(e),
+ * });
+ * if (!result.passed) { ... }
+ * console.log(`Spent $${result.totalCostUsd.toFixed(4)}`);
+ * ```
+ */
+export declare function runFullStack(opts: RunFullStackOptions): Promise<RunFullStackResult>;

package/dist/types/mendAgent.d.ts

@@ -16,10 +16,17 @@
  */
 import type { MendContext } from "./index.js";
 import { type ApplyResult, type EditBlock } from "./applyEditBlock.js";
+/**
+ * Provider identifier. Each corresponds to one `@ai-sdk/<provider>` adapter
+ * in the Vercel AI SDK. Adding a provider requires (1) the corresponding
+ * `@ai-sdk/X` dep in package.json, (2) a case in `buildLanguageModel`, and
+ * (3) the appropriate API-key env-var name documented in the CLI.
+ */
+export type LLMProvider = "anthropic" | "openai" | "google";
 export interface MendSingleFileOptions {
     context: MendContext;
     llm: {
-        provider: "anthropic";
+        provider: LLMProvider;
         model: string;
         apiKey: string;
     };
@@ -39,6 +46,12 @@ export interface MendSingleFileResult {
 export type LLMCall = (params: {
     systemBlock: string;
     userBlock: string;
+    /**
+     * Provider name. Optional for backward compatibility — when omitted,
+     * the default impl treats it as "anthropic" (matches v0.5.0 behavior).
+     * Test injection points can ignore this field.
+     */
+    provider?: LLMProvider;
     model: string;
     apiKey: string;
 }) => Promise<{

package/dist/types/runMendLoop.d.ts

@@ -22,13 +22,13 @@
  * returns. We can't iterate without writing to disk because re-validation
  * needs the actual file changes.
  */
-import type { Diagnostic, MendContext } from "./index.js";
-import { type LLMCall } from "./mendAgent.js";
+import type { Diagnostic, LayerEvent, MendContext } from "./index.js";
+import { type LLMCall, type LLMProvider } from "./mendAgent.js";
 import { type AppliedStub } from "./stubAndContinue.js";
 export interface RunMendLoopOptions {
     context: MendContext;
     llm: {
-        provider: "anthropic";
+        provider: LLMProvider;
         model: string;
         apiKey: string;
     };
@@ -43,6 +43,13 @@ export interface RunMendLoopOptions {
      * Default false. Ignored when `dryRun: true`.
      */
     stubOnFailure?: boolean;
+    /**
+     * Per-iteration / per-stub telemetry callback. Layer 2 emits one event per
+     * iteration with the dominant error code (`fixed: true` if the iteration
+     * cleared all errors); Layer 4 emits one event per stubbed `(line, code)`
+     * pair. Both forwarded to the same callback. Optional.
+     */
+    onLayerEvent?: (event: LayerEvent) => void;
     /** @internal — LLM call override for tests. */
     _callLLM?: LLMCall;
 }

package/dist/types/tsLanguageServiceFixer.d.ts

@@ -51,6 +51,13 @@ export interface LSPFixerOptions {
      * before letting it modify a workspace.
      */
     dryRun?: boolean;
+    /**
+     * Per-error telemetry callback. One event per `(errorCode, fix-attempt)`
+     * with `fixed: true` when the fix landed and `fixed: false` when the LSP
+     * abstained (no safe candidate). Events fire even on dry runs.
+     * Optional — undefined callback costs nothing.
+     */
+    onLayerEvent?: (event: import("./index.js").LayerEvent) => void;
 }
 export interface LSPFixerResult {
     /** Number of fixes successfully applied across all iterations. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shipispec/tsfix",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"description": "TypeScript error-recovery for LLM-generated code. Layer 0/1 deterministic auto-fix via the TS Language Service + Layer 2 LLM mend (Vercel AI SDK + Anthropic) in one package.",
 	"keywords": [
 		"typescript",
@@ -65,6 +65,8 @@
 	},
 	"dependencies": {
 		"@ai-sdk/anthropic": "^3.0.44",
+		"@ai-sdk/google": "^3.0.75",
+		"@ai-sdk/openai": "^3.0.64",
 		"ai": "^6.0.86"
 	},
 	"devDependencies": {