gsd-pi 2.23.0 → 2.24.0

package/dist/resources/extensions/gsd/tests/worker-registry.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Tests for the parallel worker registry used by the dashboard overlay.
+ *
+ * Verifies worker lifecycle (register → update → cleanup), batch grouping,
+ * and the hasActiveWorkers() status check.
+ */
+
+import { createTestContext } from './test-helpers.ts';
+import {
+  registerWorker,
+  updateWorker,
+  getActiveWorkers,
+  getWorkerBatches,
+  hasActiveWorkers,
+  resetWorkerRegistry,
+} from '../../subagent/worker-registry.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Setup ────────────────────────────────────────────────────────────────────
+
+resetWorkerRegistry();
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+console.log("\n=== Worker Registration ===");
+
+{
+  resetWorkerRegistry();
+  const id = registerWorker("scout", "Explore codebase", 0, 3, "batch-1");
+  assertTrue(id.startsWith("worker-"), "worker ID has correct prefix");
+  const workers = getActiveWorkers();
+  assertEq(workers.length, 1, "one worker registered");
+  assertEq(workers[0].agent, "scout", "worker agent name correct");
+  assertEq(workers[0].task, "Explore codebase", "worker task correct");
+  assertEq(workers[0].status, "running", "worker starts as running");
+  assertEq(workers[0].index, 0, "worker index correct");
+  assertEq(workers[0].batchSize, 3, "worker batch size correct");
+  assertEq(workers[0].batchId, "batch-1", "worker batch ID correct");
+}
+
+// ─── Multiple workers in a batch ──────────────────────────────────────────────
+
+console.log("\n=== Multiple Workers in a Batch ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 3, "batch-2");
+  const id2 = registerWorker("researcher", "Task B", 1, 3, "batch-2");
+  const id3 = registerWorker("worker", "Task C", 2, 3, "batch-2");
+
+  const workers = getActiveWorkers();
+  assertEq(workers.length, 3, "three workers registered");
+  assertTrue(hasActiveWorkers(), "has active workers");
+
+  const batches = getWorkerBatches();
+  assertEq(batches.size, 1, "one batch");
+  const batch = batches.get("batch-2");
+  assertTrue(batch !== undefined, "batch-2 exists");
+  assertEq(batch!.length, 3, "batch has 3 workers");
+}
+
+// ─── Worker status updates ────────────────────────────────────────────────────
+
+console.log("\n=== Worker Status Updates ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 2, "batch-3");
+  const id2 = registerWorker("worker", "Task B", 1, 2, "batch-3");
+
+  updateWorker(id1, "completed");
+  const workers = getActiveWorkers();
+  const w1 = workers.find(w => w.id === id1);
+  assertEq(w1?.status, "completed", "worker 1 marked completed");
+
+  const w2 = workers.find(w => w.id === id2);
+  assertEq(w2?.status, "running", "worker 2 still running");
+  assertTrue(hasActiveWorkers(), "still has active workers (worker 2 running)");
+}
+
+// ─── Failed worker ────────────────────────────────────────────────────────────
+
+console.log("\n=== Failed Worker ===");
+
+{
+  resetWorkerRegistry();
+  const id = registerWorker("scout", "Task A", 0, 1, "batch-4");
+  updateWorker(id, "failed");
+  const workers = getActiveWorkers();
+  assertEq(workers[0].status, "failed", "worker marked failed");
+}
+
+// ─── Multiple batches ─────────────────────────────────────────────────────────
+
+console.log("\n=== Multiple Batches ===");
+
+{
+  resetWorkerRegistry();
+  registerWorker("scout", "Task A", 0, 2, "batch-5");
+  registerWorker("worker", "Task B", 1, 2, "batch-5");
+  registerWorker("researcher", "Task C", 0, 1, "batch-6");
+
+  const batches = getWorkerBatches();
+  assertEq(batches.size, 2, "two batches");
+  assertEq(batches.get("batch-5")!.length, 2, "batch-5 has 2 workers");
+  assertEq(batches.get("batch-6")!.length, 1, "batch-6 has 1 worker");
+}
+
+// ─── hasActiveWorkers with all completed ──────────────────────────────────────
+
+console.log("\n=== hasActiveWorkers — all completed ===");
+
+{
+  resetWorkerRegistry();
+  const id1 = registerWorker("scout", "Task A", 0, 2, "batch-7");
+  const id2 = registerWorker("worker", "Task B", 1, 2, "batch-7");
+  updateWorker(id1, "completed");
+  updateWorker(id2, "completed");
+  assertTrue(!hasActiveWorkers(), "no active workers when all completed");
+}
+
+// ─── Reset clears everything ─────────────────────────────────────────────────
+
+console.log("\n=== Reset ===");
+
+{
+  registerWorker("scout", "Task", 0, 1, "batch-8");
+  assertTrue(getActiveWorkers().length > 0, "workers exist before reset");
+  resetWorkerRegistry();
+  assertEq(getActiveWorkers().length, 0, "no workers after reset");
+  assertTrue(!hasActiveWorkers(), "hasActiveWorkers false after reset");
+}
+
+// ─── Update non-existent worker is no-op ──────────────────────────────────────
+
+console.log("\n=== Update non-existent worker ===");
+
+{
+  resetWorkerRegistry();
+  // Should not throw
+  updateWorker("nonexistent-id", "completed");
+  assertEq(getActiveWorkers().length, 0, "no workers created by updating nonexistent");
+}
+
+// ─── Summary ──────────────────────────────────────────────────────────────────
+
+report();

package/dist/resources/extensions/gsd/types.ts

@@ -5,7 +5,7 @@
 // ─── Enums & Literal Unions ────────────────────────────────────────────────
 
 export type RiskLevel = 'low' | 'medium' | 'high';
-export type Phase = 'pre-planning' | 'needs-discussion' | 'discussing' | 'researching' | 'planning' | 'executing' | 'verifying' | 'summarizing' | 'advancing' | 'completing-milestone' | 'replanning-slice' | 'complete' | 'paused' | 'blocked';
+export type Phase = 'pre-planning' | 'needs-discussion' | 'discussing' | 'researching' | 'planning' | 'executing' | 'verifying' | 'summarizing' | 'advancing' | 'validating-milestone' | 'completing-milestone' | 'replanning-slice' | 'complete' | 'paused' | 'blocked';
 export type ContinueStatus = 'in_progress' | 'interrupted' | 'compacted';
 
 // ─── Roadmap (Milestone-level) ─────────────────────────────────────────────
@@ -264,6 +264,7 @@ export interface PhaseSkipPreferences {
   skip_research?: boolean;
   skip_reassess?: boolean;
   skip_slice_research?: boolean;
+  skip_milestone_validation?: boolean;
 }
 
 export interface NotificationPreferences {
@@ -363,3 +364,16 @@ export interface Requirement {
   full_content: string;     // full requirement text
   superseded_by: string | null;  // ID of superseding requirement, or null
 }
+
+// ─── Parallel Orchestration Types ────────────────────────────────────────
+
+export type MergeStrategy = "per-slice" | "per-milestone";
+export type AutoMergeMode = "auto" | "confirm" | "manual";
+
+export interface ParallelConfig {
+  enabled: boolean;
+  max_workers: number;
+  budget_ceiling?: number;
+  merge_strategy: MergeStrategy;
+  auto_merge: AutoMergeMode;
+}

package/dist/resources/extensions/subagent/index.ts

@@ -33,6 +33,7 @@ import {
 	mergeDeltaPatches,
 	readIsolationMode,
 } from "./isolation.js";
+import { registerWorker, updateWorker } from "./worker-registry.js";
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -626,7 +627,10 @@ export default function (pi: ExtensionAPI) {
 				};
 
 				const MAX_RETRIES = 1; // Retry failed tasks once
+				const batchId = crypto.randomUUID();
+				const batchSize = params.tasks.length;
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
+					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					let result = await runSingleAgent(
 						ctx.cwd,
 						agents,
@@ -666,6 +670,7 @@ export default function (pi: ExtensionAPI) {
 						);
 					}
 
+					updateWorker(workerId, result.exitCode === 0 ? "completed" : "failed");
 					allResults[index] = result;
 					emitParallelUpdate();
 					return result;

package/dist/resources/extensions/subagent/worker-registry.ts

@@ -0,0 +1,99 @@
+/**
+ * Worker Registry — Tracks active subagent sessions for dashboard visibility.
+ *
+ * Provides a global registry of currently-running parallel workers so the
+ * GSD dashboard overlay can display real-time worker status.
+ */
+
+export interface WorkerEntry {
+  id: string;
+  agent: string;
+  task: string;
+  startedAt: number;
+  status: "running" | "completed" | "failed";
+  /** Index within a parallel batch (0-based) */
+  index: number;
+  /** Total workers in the parallel batch */
+  batchSize: number;
+  /** Unique batch identifier for grouping parallel runs */
+  batchId: string;
+}
+
+const activeWorkers = new Map<string, WorkerEntry>();
+let workerIdCounter = 0;
+
+/**
+ * Register a new worker. Returns the worker ID for later updates.
+ */
+export function registerWorker(
+  agent: string,
+  task: string,
+  index: number,
+  batchSize: number,
+  batchId: string,
+): string {
+  const id = `worker-${++workerIdCounter}`;
+  activeWorkers.set(id, {
+    id,
+    agent,
+    task,
+    startedAt: Date.now(),
+    status: "running",
+    index,
+    batchSize,
+    batchId,
+  });
+  return id;
+}
+
+/**
+ * Update worker status when it completes or fails.
+ */
+export function updateWorker(id: string, status: "completed" | "failed"): void {
+  const entry = activeWorkers.get(id);
+  if (entry) {
+    entry.status = status;
+    // Remove after a brief display window (5 seconds)
+    setTimeout(() => {
+      activeWorkers.delete(id);
+    }, 5000);
+  }
+}
+
+/**
+ * Get all currently-tracked workers (running + recently completed).
+ */
+export function getActiveWorkers(): WorkerEntry[] {
+  return Array.from(activeWorkers.values());
+}
+
+/**
+ * Get workers grouped by batch.
+ */
+export function getWorkerBatches(): Map<string, WorkerEntry[]> {
+  const batches = new Map<string, WorkerEntry[]>();
+  for (const worker of activeWorkers.values()) {
+    const batch = batches.get(worker.batchId) ?? [];
+    batch.push(worker);
+    batches.set(worker.batchId, batch);
+  }
+  return batches;
+}
+
+/**
+ * Check if any parallel workers are currently running.
+ */
+export function hasActiveWorkers(): boolean {
+  for (const worker of activeWorkers.values()) {
+    if (worker.status === "running") return true;
+  }
+  return false;
+}
+
+/**
+ * Reset registry state. Used for testing.
+ */
+export function resetWorkerRegistry(): void {
+  activeWorkers.clear();
+  workerIdCounter = 0;
+}

package/dist/update-check.d.ts

@@ -21,4 +21,13 @@ export interface UpdateCheckOptions {
  * caches the result, and prints a banner if a newer version is available.
  */
 export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<void>;
+/**
+ * Interactive update prompt shown at startup when a newer version is available.
+ * Fetches the latest version (with cache), then asks the user whether to
+ * update now or skip. Runs at most once per 24 hours (same cache as checkForUpdates).
+ * Defaults to skip after 30 seconds of inactivity.
+ *
+ * Returns true if an update was performed, false otherwise.
+ */
+export declare function checkAndPromptForUpdates(options?: UpdateCheckOptions): Promise<boolean>;
 export {};

package/dist/update-check.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import chalk from 'chalk';
 import { appRoot } from './app-paths.js';
+import { execSync } from 'node:child_process';
 const CACHE_FILE = join(appRoot, '.update-check');
 const NPM_PACKAGE_NAME = 'gsd-pi';
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -88,3 +89,99 @@ export async function checkForUpdates(options = {}) {
         clearTimeout(timeout);
     }
 }
+const PROMPT_TIMEOUT_MS = 30_000;
+/**
+ * Interactive update prompt shown at startup when a newer version is available.
+ * Fetches the latest version (with cache), then asks the user whether to
+ * update now or skip. Runs at most once per 24 hours (same cache as checkForUpdates).
+ * Defaults to skip after 30 seconds of inactivity.
+ *
+ * Returns true if an update was performed, false otherwise.
+ */
+export async function checkAndPromptForUpdates(options = {}) {
+    const currentVersion = options.currentVersion || process.env.GSD_VERSION || '0.0.0';
+    const cachePath = options.cachePath || CACHE_FILE;
+    const registryUrl = options.registryUrl || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+    const checkIntervalMs = options.checkIntervalMs ?? CHECK_INTERVAL_MS;
+    const fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+    // Determine latest version (from cache or network)
+    let latestVersion = null;
+    const cache = readUpdateCache(cachePath);
+    if (cache && Date.now() - cache.lastCheck < checkIntervalMs) {
+        latestVersion = cache.latestVersion;
+    }
+    else {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+        try {
+            const res = await fetch(registryUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (res.ok) {
+                const data = (await res.json());
+                if (data.version) {
+                    latestVersion = data.version;
+                    writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
+                }
+            }
+        }
+        catch {
+            // Network unavailable — silently skip
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    if (!latestVersion || compareSemver(latestVersion, currentVersion) <= 0) {
+        return false;
+    }
+    // Update available — show interactive prompt
+    // Measure visible (ANSI-free) width to size the box, then render with chalk.
+    const midContent = `  ${chalk.bold('Update available!')} ${chalk.dim(`v${currentVersion}`)} → ${chalk.bold.green(`v${latestVersion}`)}  `;
+    const midVisible = `  Update available! v${currentVersion} → v${latestVersion}  `;
+    const innerWidth = midVisible.length;
+    const top = '╔' + '═'.repeat(innerWidth) + '╗';
+    const bot = '╚' + '═'.repeat(innerWidth) + '╝';
+    process.stderr.write('\n');
+    process.stderr.write(`  ${chalk.yellow(top)}\n` +
+        `  ${chalk.yellow('║')}${midContent}${chalk.yellow('║')}\n` +
+        `  ${chalk.yellow(bot)}\n\n`);
+    // Use readline for a simple two-option prompt that works without @clack/prompts
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    const choice = await new Promise((resolve) => {
+        process.stderr.write(`  ${chalk.bold('[1]')} Update now   ${chalk.dim(`npm install -g ${NPM_PACKAGE_NAME}@latest`)}\n` +
+            `  ${chalk.bold('[2]')} Skip\n\n`);
+        // Default to skip if the user doesn't respond within PROMPT_TIMEOUT_MS
+        const timer = setTimeout(() => {
+            process.stderr.write('\n');
+            rl.close();
+            resolve('2');
+        }, PROMPT_TIMEOUT_MS);
+        rl.question(`  ${chalk.bold('Choose [1/2]:')} `, (answer) => {
+            clearTimeout(timer);
+            resolve(answer.trim());
+        });
+    });
+    rl.close();
+    // Clean up stdin state so the TUI can start with a clean slate
+    process.stdin.removeAllListeners('data');
+    process.stdin.removeAllListeners('keypress');
+    if (process.stdin.setRawMode)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
+    if (choice === '1') {
+        process.stderr.write(`\n  ${chalk.dim('Running:')} npm install -g ${NPM_PACKAGE_NAME}@latest\n\n`);
+        try {
+            execSync(`npm install -g ${NPM_PACKAGE_NAME}@latest`, { stdio: 'inherit' });
+            process.stderr.write(`\n  ${chalk.green.bold(`✓ Updated to v${latestVersion}`)}\n\n`);
+            return true;
+        }
+        catch {
+            process.stderr.write(`\n  ${chalk.yellow(`Update failed. You can run: npm install -g ${NPM_PACKAGE_NAME}@latest`)}\n\n`);
+        }
+    }
+    else {
+        process.stderr.write(`  ${chalk.dim('Skipped. Run')} gsd update ${chalk.dim('anytime to upgrade.')}\n\n`);
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.23.0",
+  "version": "2.24.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -56,6 +56,11 @@
     "build:native": "node native/scripts/build.js",
     "build:native:dev": "node native/scripts/build.js --dev",
     "dev": "node scripts/dev.js",
+    "dev:symlink": "bash scripts/dev-symlink.sh",
+    "dev:symlink:remove": "bash scripts/dev-symlink.sh --remove",
+    "dev:symlink:status": "bash scripts/dev-symlink.sh --status",
+    "dev:clean": "rm -rf ~/.gsd/agent/{extensions,skills,agents,AGENTS.md} && npm run build && npm run pi:install-global",
+    "dev:full": "npm run dev:clean && node dist/loader.js",
     "postinstall": "node scripts/link-workspace-packages.cjs && node scripts/postinstall.js",
     "pi:install-global": "node scripts/install-pi-global.js",
     "pi:uninstall-global": "node scripts/uninstall-pi-global.js",

package/packages/pi-ai/dist/providers/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/providers/anthropic.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAQX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAiIrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACtE;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG;IAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,SAAS,SAAK,GAAG,MAAM,GAAG,SAAS,CA8B/H;AAED,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAgPlF,CAAC;AAoCF,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAuC3F,CAAC"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/providers/anthropic.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAQX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AA0IrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACtE;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG;IAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,SAAS,SAAK,GAAG,MAAM,GAAG,SAAS,CA8B/H;AAED,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAiPlF,CAAC;AAoCF,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAuC3F,CAAC"}

package/packages/pi-ai/dist/providers/anthropic.js

@@ -1,4 +1,3 @@
-import Anthropic from "@anthropic-ai/sdk";
 import { getEnvApiKey } from "../env-api-keys.js";
 import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
@@ -7,6 +6,14 @@ import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
+let _AnthropicClass;
+async function getAnthropicClass() {
+    if (!_AnthropicClass) {
+        const mod = await import("@anthropic-ai/sdk");
+        _AnthropicClass = mod.default;
+    }
+    return _AnthropicClass;
+}
 /**
  * Resolve cache retention preference.
  * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
@@ -178,7 +185,7 @@ export const streamAnthropic = (model, context, options) => {
                     hasImages,
                 });
             }
-            const { client, isOAuthToken } = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
+            const { client, isOAuthToken } = await createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
             let params = buildParams(model, context, isOAuthToken, options);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
@@ -370,7 +377,8 @@ export const streamAnthropic = (model, context, options) => {
             if (model.provider === "alibaba-coding-plan") {
                 output.errorMessage = `[alibaba-coding-plan] ${output.errorMessage}`;
             }
-            if (error instanceof Anthropic.APIError && error.headers) {
+            const AnthropicSdk = _AnthropicClass;
+            if (AnthropicSdk && error instanceof AnthropicSdk.APIError && error.headers) {
                 const retryAfterMs = extractRetryAfterMs(error.headers, error.message);
                 if (retryAfterMs !== undefined) {
                     output.retryAfterMs = retryAfterMs;
@@ -442,7 +450,8 @@ export const streamSimpleAnthropic = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynamicHeaders) {
+async function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynamicHeaders) {
+    const AnthropicClass = await getAnthropicClass();
     // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
     // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
     const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
@@ -452,7 +461,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         if (needsInterleavedBeta) {
             betaFeatures.push("interleaved-thinking-2025-05-14");
         }
-        const client = new Anthropic({
+        const client = new AnthropicClass({
             apiKey: null,
             authToken: apiKey,
             baseURL: model.baseUrl,
@@ -473,7 +482,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
     }
     // OAuth: Bearer auth, Claude Code identity headers
     if (isOAuthToken(apiKey)) {
-        const client = new Anthropic({
+        const client = new AnthropicClass({
             apiKey: null,
             authToken: apiKey,
             baseURL: model.baseUrl,
@@ -491,7 +500,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
     // API key auth
     // Alibaba Coding Plan uses Bearer token auth instead of x-api-key
     const isAlibabaProvider = model.provider === "alibaba-coding-plan";
-    const client = new Anthropic({
+    const client = new AnthropicClass({
         apiKey: isAlibabaProvider ? null : apiKey,
         authToken: isAlibabaProvider ? apiKey : undefined,
         baseURL: model.baseUrl,