@workermill/agent 0.7.7 → 0.7.9

package/dist/ai-sdk-generate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AI SDK Text Generation with Tool Support
+ *
+ * Wraps the Vercel AI SDK to provide tool-enabled text generation for
+ * non-Anthropic providers (OpenAI, Google, Ollama). Anthropic planning
+ * still uses Claude CLI for tool access (battle-tested, OAuth auth).
+ *
+ * Tools: glob (file search), read_file (file reading), grep (content search).
+ * These match the tools Claude CLI exposes to analysts.
+ */
+import type { AIProvider } from "./providers.js";
+export interface GenerateWithToolsOptions {
+    provider: AIProvider;
+    model: string;
+    apiKey: string;
+    prompt: string;
+    systemPrompt?: string;
+    workingDir?: string;
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+    maxSteps?: number;
+    /** Enable tool use (glob, read_file, grep). Default: true */
+    enableTools?: boolean;
+}
+/**
+ * Generate text using the Vercel AI SDK with optional tool support.
+ *
+ * For providers that support tool calling (OpenAI, Google, Anthropic),
+ * the model can use glob/read_file/grep to explore a cloned repo.
+ * maxSteps controls how many tool call rounds are allowed.
+ */
+export declare function generateTextWithTools(options: GenerateWithToolsOptions): Promise<string>;

package/dist/ai-sdk-generate.js

@@ -0,0 +1,160 @@
+/**
+ * AI SDK Text Generation with Tool Support
+ *
+ * Wraps the Vercel AI SDK to provide tool-enabled text generation for
+ * non-Anthropic providers (OpenAI, Google, Ollama). Anthropic planning
+ * still uses Claude CLI for tool access (battle-tested, OAuth auth).
+ *
+ * Tools: glob (file search), read_file (file reading), grep (content search).
+ * These match the tools Claude CLI exposes to analysts.
+ */
+import { generateText as aiGenerateText, tool, stepCountIs } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { z } from "zod";
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+/**
+ * Create the AI SDK model instance for a given provider.
+ */
+function createModel(provider, model, apiKey) {
+    switch (provider) {
+        case "anthropic": {
+            const anthropic = createAnthropic({ apiKey });
+            return anthropic(model);
+        }
+        case "openai": {
+            const openai = createOpenAI({ apiKey });
+            return openai(model);
+        }
+        case "google": {
+            const google = createGoogleGenerativeAI({ apiKey });
+            return google(model);
+        }
+        case "ollama": {
+            // Ollama uses OpenAI-compatible API
+            const ollama = createOpenAI({
+                baseURL: apiKey || "http://localhost:11434/v1",
+                apiKey: "ollama", // Ollama doesn't need a real key
+            });
+            return ollama(model);
+        }
+        default:
+            throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+}
+// Zod schemas for tool inputs
+const globSchema = z.object({
+    pattern: z
+        .string()
+        .describe("Glob pattern like '**/*.ts', 'src/**/*.js', 'package.json'"),
+});
+const readFileSchema = z.object({
+    path: z.string().describe("File path relative to the working directory"),
+    limit: z
+        .number()
+        .optional()
+        .describe("Max number of lines to read (default: 500)"),
+});
+const grepSchema = z.object({
+    pattern: z.string().describe("Search pattern (regex supported)"),
+    glob: z
+        .string()
+        .optional()
+        .describe("File glob to filter (e.g. '*.ts', '*.py')"),
+});
+/**
+ * Build filesystem tools scoped to a working directory.
+ * These are the same tools Claude CLI exposes (Glob, Read, Grep).
+ */
+function buildTools(workingDir) {
+    return {
+        glob: tool({
+            description: "Find files matching a glob pattern. Returns file paths relative to the working directory.",
+            inputSchema: globSchema,
+            execute: async (input) => {
+                try {
+                    // Use find as a cross-platform glob (fast-glob not available)
+                    const result = execSync(`find . -path './.git' -prune -o -path './node_modules' -prune -o -name '${input.pattern.replace(/\*\*/g, "*")}' -print 2>/dev/null | head -200`, { cwd: workingDir, encoding: "utf-8", timeout: 15000 }).trim();
+                    if (!result) {
+                        // Try with a broader approach for ** patterns
+                        const broader = execSync(`find . -path './.git' -prune -o -path './node_modules' -prune -o -type f -print 2>/dev/null | head -500`, { cwd: workingDir, encoding: "utf-8", timeout: 15000 }).trim();
+                        return broader || "No files found";
+                    }
+                    return result;
+                }
+                catch {
+                    return "Error running glob search";
+                }
+            },
+        }),
+        read_file: tool({
+            description: "Read the contents of a file. Returns the file text.",
+            inputSchema: readFileSchema,
+            execute: async (input) => {
+                try {
+                    const fullPath = `${workingDir}/${input.path}`.replace(/\/\//g, "/");
+                    if (!existsSync(fullPath)) {
+                        return `File not found: ${input.path}`;
+                    }
+                    const content = readFileSync(fullPath, "utf-8");
+                    const lines = content.split("\n");
+                    const maxLines = input.limit || 500;
+                    if (lines.length > maxLines) {
+                        return (lines.slice(0, maxLines).join("\n") +
+                            `\n... (truncated, ${lines.length - maxLines} more lines)`);
+                    }
+                    return content;
+                }
+                catch (err) {
+                    return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
+        grep: tool({
+            description: "Search for a pattern in files. Returns matching lines with file paths and line numbers.",
+            inputSchema: grepSchema,
+            execute: async (input) => {
+                try {
+                    const includeFlag = input.glob ? `--include='${input.glob}'` : "";
+                    const result = execSync(`grep -rn ${includeFlag} --exclude-dir=node_modules --exclude-dir=.git '${input.pattern.replace(/'/g, "'\\''")}' . 2>/dev/null | head -100`, { cwd: workingDir, encoding: "utf-8", timeout: 15000 }).trim();
+                    return result || "No matches found";
+                }
+                catch {
+                    return "No matches found";
+                }
+            },
+        }),
+    };
+}
+/**
+ * Generate text using the Vercel AI SDK with optional tool support.
+ *
+ * For providers that support tool calling (OpenAI, Google, Anthropic),
+ * the model can use glob/read_file/grep to explore a cloned repo.
+ * maxSteps controls how many tool call rounds are allowed.
+ */
+export async function generateTextWithTools(options) {
+    const { provider, model: modelName, apiKey, prompt, systemPrompt, workingDir, maxTokens = 16384, temperature = 0.7, timeoutMs = 600_000, maxSteps = 15, enableTools = true, } = options;
+    const sdkModel = createModel(provider, modelName, apiKey);
+    const tools = enableTools && workingDir ? buildTools(workingDir) : undefined;
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), timeoutMs);
+    try {
+        const result = await aiGenerateText({
+            model: sdkModel,
+            prompt,
+            system: systemPrompt,
+            maxOutputTokens: maxTokens,
+            temperature,
+            tools,
+            stopWhen: tools ? stepCountIs(maxSteps) : undefined,
+            abortSignal: abortController.signal,
+        });
+        return result.text;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/planner.js

@@ -15,11 +15,12 @@
  * sees the same planning progress as cloud mode.
  */
 import chalk from "chalk";
+import ora from "ora";
 import { spawn, execSync } from "child_process";
 import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
 import { parseExecutionPlan, applyFileCap, applyStoryCap, serializePlan, runCriticValidation, formatCriticFeedback, AUTO_APPROVAL_THRESHOLD, } from "./plan-validator.js";
-import { generateText } from "./providers.js";
+import { generateTextWithTools } from "./ai-sdk-generate.js";
 /** Max Planner-Critic iterations before giving up */
 const MAX_ITERATIONS = 3;
 /** Timestamp prefix */
@@ -103,6 +104,23 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         let stderrOutput = "";
         let charsReceived = 0;
         let toolCallCount = 0;
+        // Live spinner — shows elapsed time, phase, and chars generated
+        const spinner = ora({
+            text: `${taskLabel} Initializing planner...`,
+            prefixText: "",
+            spinner: "dots",
+        }).start();
+        function updateSpinner() {
+            const elapsed = Math.round((Date.now() - startTime) / 1000);
+            const phaseIcon = currentPhase === "reading_repo" ? "📂" :
+                currentPhase === "analyzing" ? "🔍" :
+                    currentPhase === "generating_plan" ? "📝" :
+                        currentPhase === "validating" ? "✅" : "⏳";
+            const stats = chalk.dim(`${formatElapsed(elapsed)} · ${charsReceived} chars · ${toolCallCount} tools`);
+            spinner.text = `${taskLabel} ${phaseIcon} ${phaseLabel(currentPhase, elapsed)}  ${stats}`;
+        }
+        // Update spinner every 500ms for smooth elapsed time display
+        const spinnerInterval = setInterval(updateSpinner, 500);
         // Buffered text streaming — flush complete lines to dashboard every 1s.
         // LLM deltas are tiny fragments; we accumulate until we see '\n', then
         // a 1s interval flushes all complete lines as log entries.  On exit we
@@ -117,6 +135,11 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             for (const line of parts) {
                 if (line.trim()) {
                     postLog(taskId, `${PREFIX} ${line}`, "output");
+                    // Echo planner thoughts to local terminal
+                    spinner.stop();
+                    const truncated = line.trim().length > 160 ? line.trim().substring(0, 160) + "…" : line.trim();
+                    console.log(`${ts()} ${taskLabel} ${chalk.dim("💭")} ${chalk.dim(truncated)}`);
+                    spinner.start();
                 }
             }
             textBuffer = incomplete;
@@ -133,7 +156,10 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
             const elapsed = Math.round((Date.now() - startTime) / 1000);
             const msg = phaseLabel(newPhase, elapsed);
             postLog(taskId, msg);
+            spinner.stop();
             console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
+            spinner.start();
+            updateSpinner();
         }
         // Flush buffered LLM text to dashboard every 1s (complete lines only)
         const textFlushInterval = setInterval(() => flushTextBuffer(), 1_000);
@@ -159,7 +185,9 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
                 lastProgressLogAt = elapsed;
                 const msg = `${PREFIX} Planning in progress — analyzing requirements and decomposing into steps (${formatElapsed(elapsed)} elapsed)`;
                 postLog(taskId, msg);
+                spinner.stop();
                 console.log(`${ts()} ${taskLabel} ${chalk.dim(msg)}`);
+                spinner.start();
             }
         }, 5_000);
         // Parse streaming JSON lines from Claude CLI
@@ -248,20 +276,22 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         proc.stderr.on("data", (chunk) => {
             stderrOutput += chunk.toString();
         });
-        const timeout = setTimeout(() => {
+        function cleanupAll() {
             clearInterval(progressInterval);
             clearInterval(sseProgressInterval);
             clearInterval(textFlushInterval);
+            clearInterval(spinnerInterval);
             flushTextBuffer(true);
+            spinner.stop();
+        }
+        const timeout = setTimeout(() => {
+            cleanupAll();
             proc.kill("SIGTERM");
             reject(new Error("Claude CLI timed out after 20 minutes"));
         }, 1_200_000);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
-            clearInterval(progressInterval);
-            clearInterval(sseProgressInterval);
-            clearInterval(textFlushInterval);
-            flushTextBuffer(true);
+            cleanupAll();
             // Emit final "validating" phase to dashboard
             const elapsedAtClose = Math.round((Date.now() - startTime) / 1000);
             postProgress(taskId, "validating", elapsedAtClose, "Validating plan...", charsReceived, toolCallCount);
@@ -275,10 +305,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         });
         proc.on("error", (err) => {
             clearTimeout(timeout);
-            clearInterval(progressInterval);
-            clearInterval(sseProgressInterval);
-            clearInterval(textFlushInterval);
-            flushTextBuffer(true);
+            cleanupAll();
             reject(err);
         });
     });
@@ -351,10 +378,14 @@ async function cloneTargetRepo(repo, token, scmProvider, taskId) {
  * Run an analyst agent via Claude CLI with tool access to the cloned repo.
  * Returns the analyst's report text, or an empty string on failure.
  */
-function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs = 900_000) {
+function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs = 900_000, taskId) {
     const label = chalk.blue(`[${name}]`);
+    const modelLabel = chalk.yellow(model);
     return new Promise((resolve) => {
-        console.log(`${ts()} ${label} Starting (${chalk.dim(model)})...`);
+        console.log(`${ts()} ${label} Starting analyst using ${modelLabel}...`);
+        if (taskId) {
+            postLog(taskId, `${PREFIX} [${name}] Starting analyst using ${model}...`);
+        }
         const proc = spawn(claudePath, [
             "--print",
             "--verbose",
@@ -376,12 +407,23 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         let toolCalls = 0;
         let timedOut = false;
         const startMs = Date.now();
+        // Live spinner for this analyst
+        const analystSpinner = ora({
+            text: `${label} Starting (${model})...`,
+            spinner: "dots",
+        }).start();
+        const analystSpinnerInterval = setInterval(() => {
+            const elapsed = Math.round((Date.now() - startMs) / 1000);
+            analystSpinner.text = `${label} ${chalk.dim(`${formatElapsed(elapsed)} · ${toolCalls} tools · ${fullText.length} chars`)}`;
+        }, 500);
         proc.stderr.on("data", (chunk) => {
             const text = chunk.toString();
             stderrOutput += text;
             // Show stderr in real-time so we can see what's happening
             for (const line of text.split("\n").filter((l) => l.trim())) {
+                analystSpinner.stop();
                 console.log(`${ts()} ${label} ${chalk.red("stderr:")} ${line.trim()}`);
+                analystSpinner.start();
             }
         });
         proc.stdout.on("data", (data) => {
@@ -404,7 +446,11 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                                     // Log analyst reasoning (first line, truncated)
                                     const thought = block.text.trim().split("\n")[0].substring(0, 120);
                                     if (thought) {
+                                        analystSpinner.stop();
                                         console.log(`${ts()} ${label} ${chalk.dim("💭")} ${chalk.dim(thought)}`);
+                                        if (taskId)
+                                            postLog(taskId, `${PREFIX} [${name}] 💭 ${thought}`);
+                                        analystSpinner.start();
                                     }
                                 }
                                 else if (block.type === "tool_use") {
@@ -413,7 +459,11 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                                     // Show tool name + input preview (file path, pattern, etc.)
                                     const inputStr = block.input ? JSON.stringify(block.input) : "";
                                     const inputPreview = inputStr.length > 80 ? inputStr.substring(0, 80) + "…" : inputStr;
-                                    console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}${inputPreview ? chalk.dim(` ${inputPreview}`) : ""} (${toolCalls} total)`);
+                                    analystSpinner.stop();
+                                    console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}${inputPreview ? chalk.dim(` ${inputPreview}`) : ""}`);
+                                    if (taskId)
+                                        postLog(taskId, `${PREFIX} [${name}] Tool: ${toolName} ${inputPreview}`);
+                                    analystSpinner.start();
                                 }
                             }
                         }
@@ -428,7 +478,11 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
                     else if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
                         toolCalls++;
                         const toolName = event.content_block?.name || "unknown";
-                        console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)} (${toolCalls} total)`);
+                        analystSpinner.stop();
+                        console.log(`${ts()} ${label} ${chalk.dim(`Tool: ${toolName}`)}`);
+                        if (taskId)
+                            postLog(taskId, `${PREFIX} [${name}] Tool: ${toolName}`);
+                        analystSpinner.start();
                     }
                     else if (event.type === "result" && event.result) {
                         resultText =
@@ -442,35 +496,89 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         });
         const timeout = setTimeout(() => {
             timedOut = true;
+            clearInterval(analystSpinnerInterval);
+            analystSpinner.stop();
             proc.kill("SIGTERM");
             const elapsed = Math.round((Date.now() - startMs) / 1000);
-            console.log(`${ts()} ${label} ${chalk.yellow("⚠ Timed out")} after ${elapsed}s (${toolCalls} tool calls, ${fullText.length} chars)`);
+            console.log(`${ts()} ${label} ${chalk.yellow("⚠ Timed out")} after ${formatElapsed(elapsed)} (${toolCalls} tool calls, ${fullText.length} chars)`);
+            if (taskId)
+                postLog(taskId, `${PREFIX} [${name}] ⚠ Timed out after ${formatElapsed(elapsed)}`);
             resolve(resultText || fullText || "");
         }, timeoutMs);
         proc.on("exit", (code) => {
             clearTimeout(timeout);
+            clearInterval(analystSpinnerInterval);
+            analystSpinner.stop();
             const elapsed = Math.round((Date.now() - startMs) / 1000);
             if (timedOut)
                 return; // already resolved
             const output = resultText || fullText || "";
             if (code === 0 && output.length > 0) {
-                console.log(`${ts()} ${label} ${chalk.green("✓ Done")} in ${elapsed}s (${toolCalls} tool calls, ${output.length} chars)`);
+                console.log(`${ts()} ${label} ${chalk.green("✓ Done")} in ${formatElapsed(elapsed)} (${toolCalls} tool calls, ${output.length} chars)`);
+                if (taskId)
+                    postLog(taskId, `${PREFIX} [${name}] ✓ Done in ${formatElapsed(elapsed)} (${toolCalls} tool calls, ${output.length} chars)`);
             }
             else if (code !== 0) {
-                console.log(`${ts()} ${label} ${chalk.red(`✗ Exited ${code}`)} after ${elapsed}s — ${stderrOutput.substring(0, 150) || "no stderr"}`);
+                console.log(`${ts()} ${label} ${chalk.red(`✗ Exited ${code}`)} after ${formatElapsed(elapsed)} — ${stderrOutput.substring(0, 150) || "no stderr"}`);
+                if (taskId)
+                    postLog(taskId, `${PREFIX} [${name}] ✗ Exited ${code} after ${formatElapsed(elapsed)}`);
             }
             else {
-                console.log(`${ts()} ${label} ${chalk.yellow("⚠ Empty output")} after ${elapsed}s (${toolCalls} tool calls)`);
+                console.log(`${ts()} ${label} ${chalk.yellow("⚠ Empty output")} after ${formatElapsed(elapsed)} (${toolCalls} tool calls)`);
+                if (taskId)
+                    postLog(taskId, `${PREFIX} [${name}] ⚠ Empty output after ${formatElapsed(elapsed)}`);
             }
             resolve(output);
         });
         proc.on("error", (err) => {
             clearTimeout(timeout);
+            clearInterval(analystSpinnerInterval);
+            analystSpinner.stop();
             console.log(`${ts()} ${label} ${chalk.red("✗ Spawn failed:")} ${err.message}`);
             resolve("");
         });
     });
 }
+/**
+ * Run an analyst agent via Vercel AI SDK with tool access to the cloned repo.
+ * Used for non-Anthropic providers (OpenAI, Google, Ollama) that can't use Claude CLI.
+ * Returns the analyst's report text, or an empty string on failure.
+ */
+async function runAnalystWithSdk(name, provider, model, apiKey, prompt, repoPath, timeoutMs = 900_000, taskId) {
+    const label = chalk.blue(`[${name}]`);
+    const modelLabel = chalk.yellow(`${provider}/${model}`);
+    const startMs = Date.now();
+    console.log(`${ts()} ${label} Starting analyst using ${modelLabel} via AI SDK...`);
+    if (taskId)
+        postLog(taskId, `${PREFIX} [${name}] Starting analyst using ${provider}/${model} via AI SDK...`);
+    try {
+        const result = await generateTextWithTools({
+            provider,
+            model,
+            apiKey,
+            prompt,
+            workingDir: repoPath,
+            maxTokens: 16384,
+            temperature: 0.3,
+            timeoutMs,
+            maxSteps: 20, // Allow thorough exploration
+            enableTools: true,
+        });
+        const elapsed = Math.round((Date.now() - startMs) / 1000);
+        if (result && result.length > 0) {
+            console.log(`${ts()} ${label} ${chalk.green("✓ Done")} in ${elapsed}s (${result.length} chars)`);
+            return result;
+        }
+        console.log(`${ts()} ${label} ${chalk.yellow("⚠ Empty output")} after ${elapsed}s`);
+        return "";
+    }
+    catch (error) {
+        const elapsed = Math.round((Date.now() - startMs) / 1000);
+        const errMsg = error instanceof Error ? error.message : String(error);
+        console.log(`${ts()} ${label} ${chalk.red(`✗ Failed`)} after ${elapsed}s: ${errMsg.substring(0, 150)}`);
+        return "";
+    }
+}
 /** Analyst prompt templates */
 const CODEBASE_ANALYST_PROMPT = `You are a codebase analyst. Your job is to explore this repository using tools and report what you find.
 
@@ -546,13 +654,25 @@ Keep your report under 1500 words. Only report facts you verified with tools.`;
  * This runs ONCE before the planner-critic loop — analyst prompts don't
  * include critic feedback, so re-running them on iteration 2+ is waste.
  */
-async function runTeamAnalysis(task, basePrompt, claudePath, model, env, repoPath, taskId, startTime) {
+async function runTeamAnalysis(task, basePrompt, claudePath, model, env, repoPath, taskId, startTime, provider = "anthropic", providerApiKey) {
     const taskLabel = chalk.cyan(taskId.slice(0, 8));
     console.log(`${ts()} ${taskLabel} ${chalk.magenta("◆ Team planning")} — running 3 analysts in parallel...`);
     await postLog(taskId, `${PREFIX} Team planning: running codebase, requirements, and risk analysts in parallel...`);
     await postProgress(taskId, "reading_repo", Math.round((Date.now() - startTime) / 1000), "Running parallel analysis agents...", 0, 0);
     const analysisModel = model;
     const MAX_TEAM_RETRIES = 3;
+    const useCliAnalysts = provider === "anthropic";
+    // Helper: dispatch analyst to Claude CLI or AI SDK based on provider
+    const dispatchAnalyst = (name, prompt) => {
+        if (useCliAnalysts) {
+            return runAnalyst(name, claudePath, analysisModel, prompt, repoPath, env, 900_000, taskId);
+        }
+        if (!providerApiKey) {
+            console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} No API key for ${provider} analysts, skipping ${name}`);
+            return Promise.resolve("");
+        }
+        return runAnalystWithSdk(name, provider, analysisModel, providerApiKey, prompt, repoPath, 900_000, taskId);
+    };
     let codebaseReport = "";
     let requirementsReport = "";
     let riskReport = "";
@@ -562,9 +682,9 @@ async function runTeamAnalysis(task, basePrompt, claudePath, model, env, repoPat
             await postLog(taskId, `${PREFIX} Team analysis retry ${attempt}/${MAX_TEAM_RETRIES}...`);
         }
         const [codebaseResult, requirementsResult, riskResult] = await Promise.allSettled([
-            codebaseReport ? Promise.resolve(codebaseReport) : runAnalyst("Codebase", claudePath, analysisModel, CODEBASE_ANALYST_PROMPT, repoPath, env),
-            requirementsReport ? Promise.resolve(requirementsReport) : runAnalyst("Requirements", claudePath, analysisModel, makeRequirementsAnalystPrompt(task), repoPath, env),
-            riskReport ? Promise.resolve(riskReport) : runAnalyst("Risk", claudePath, analysisModel, makeRiskAssessorPrompt(task), repoPath, env),
+            codebaseReport ? Promise.resolve(codebaseReport) : dispatchAnalyst("Codebase", CODEBASE_ANALYST_PROMPT),
+            requirementsReport ? Promise.resolve(requirementsReport) : dispatchAnalyst("Requirements", makeRequirementsAnalystPrompt(task)),
+            riskReport ? Promise.resolve(riskReport) : dispatchAnalyst("Risk", makeRiskAssessorPrompt(task)),
         ]);
         if (!codebaseReport && codebaseResult.status === "fulfilled") {
             codebaseReport = codebaseResult.value;
@@ -646,7 +766,7 @@ export async function planTask(task, config, credentials) {
     // on iteration 2+ wastes compute (they'd produce the same reports).
     let repoPath = null;
     let enhancedBasePrompt = basePrompt;
-    if (isAnthropicPlanning && config.teamPlanningEnabled && task.githubRepo) {
+    if (config.teamPlanningEnabled && task.githubRepo) {
         const scmProvider = task.scmProvider || "github";
         const scmToken = scmProvider === "bitbucket"
             ? config.bitbucketToken
@@ -661,8 +781,9 @@ export async function planTask(task, config, credentials) {
         }
         if (repoPath) {
             const analystModel = config.analystModel || cliModel;
-            console.log(`${ts()} ${taskLabel} Analysts using model: ${chalk.yellow(analystModel)} (planner: ${chalk.yellow(cliModel)})`);
-            const analysisResult = await runTeamAnalysis(task, basePrompt, claudePath, analystModel, cleanEnv, repoPath, task.id, startTime);
+            const analystBackend = isAnthropicPlanning ? "Claude CLI" : `${provider} AI SDK`;
+            console.log(`${ts()} ${taskLabel} Analysts using model: ${chalk.yellow(analystModel)} via ${chalk.dim(analystBackend)} (planner: ${chalk.yellow(cliModel)})`);
+            const analysisResult = await runTeamAnalysis(task, basePrompt, claudePath, analystModel, cleanEnv, repoPath, task.id, startTime, provider, providerApiKey);
             if (analysisResult) {
                 enhancedBasePrompt = analysisResult;
             }
@@ -701,8 +822,17 @@ export async function planTask(task, config, credentials) {
                         throw new Error(`No API key available for provider "${provider}". Configure it in Settings > Integrations.`);
                     }
                     const genStart = Math.round((Date.now() - startTime) / 1000);
-                    await postProgress(task.id, "generating_plan", genStart, "Generating plan via API...", 0, 0);
-                    rawOutput = await generateText(provider, cliModel, currentPrompt, providerApiKey);
+                    await postProgress(task.id, "generating_plan", genStart, "Generating plan via AI SDK...", 0, 0);
+                    // Use AI SDK with tool access to cloned repo (if available)
+                    rawOutput = await generateTextWithTools({
+                        provider,
+                        model: cliModel,
+                        apiKey: providerApiKey,
+                        prompt: currentPrompt,
+                        workingDir: repoPath || undefined,
+                        enableTools: !!repoPath, // Only enable tools if we have a cloned repo
+                        maxSteps: 10,
+                    });
                     // Post "validating" phase so the dashboard progress bar transitions correctly
                     const genEnd = Math.round((Date.now() - startTime) / 1000);
                     await postProgress(task.id, "validating", genEnd, "Validating plan...", rawOutput.length, 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workermill/agent",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,11 +20,16 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/google": "^3.0.0",
+    "@ai-sdk/openai": "^3.0.0",
+    "ai": "^6.0.0",
     "axios": "^1.7.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "inquirer": "^9.2.0",
-    "ora": "^8.0.0"
+    "ora": "^8.0.0",
+    "zod": "^3.23.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",