@workermill/agent 0.7.6 → 0.7.8

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/config.d.ts

@@ -17,7 +17,7 @@ export interface AgentConfig {
     gitlabToken: string;
     workerImage: string;
     teamPlanningEnabled: boolean;
-    analystModel: string;
+    analystModel?: string;
 }
 export interface FileConfig {
     apiUrl: string;

package/dist/config.js

@@ -76,7 +76,7 @@ export function loadConfigFromFile() {
         gitlabToken: fc.tokens?.gitlab || "",
         workerImage,
         teamPlanningEnabled: fc.teamPlanningEnabled ?? true,
-        analystModel: fc.analystModel || "sonnet",
+        analystModel: fc.analystModel,
     };
 }
 /**
@@ -122,7 +122,7 @@ export function loadConfig() {
         gitlabToken: process.env.GITLAB_TOKEN || "",
         workerImage: process.env.WORKER_IMAGE || "workermill-worker:local",
         teamPlanningEnabled: process.env.TEAM_PLANNING_ENABLED !== "false",
-        analystModel: process.env.ANALYST_MODEL || "sonnet",
+        analystModel: process.env.ANALYST_MODEL,
     };
 }
 /**

package/dist/planner.js

@@ -19,7 +19,7 @@ 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 */
@@ -471,6 +471,43 @@ function runAnalyst(name, claudePath, model, prompt, repoPath, env, timeoutMs =
         });
     });
 }
+/**
+ * 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) {
+    const label = chalk.blue(`[${name}]`);
+    const startMs = Date.now();
+    console.log(`${ts()} ${label} Starting via AI SDK (${chalk.dim(`${provider}/${model}`)})...`);
+    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 +583,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);
+        }
+        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);
+    };
     let codebaseReport = "";
     let requirementsReport = "";
     let riskReport = "";
@@ -562,9 +611,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;
@@ -630,7 +679,7 @@ export async function planTask(task, config, credentials) {
     });
     const { prompt: basePrompt, model, provider: planningProvider, maxStories: apiMaxStories } = promptResponse.data;
     const maxStories = typeof apiMaxStories === "number" ? apiMaxStories : 8;
-    const cliModel = model || "sonnet";
+    const cliModel = model;
     const provider = (planningProvider || "anthropic");
     const isAnthropicPlanning = provider === "anthropic";
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
@@ -646,7 +695,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
@@ -660,9 +709,10 @@ export async function planTask(task, config, credentials) {
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} No SCM token for ${scmProvider}, skipping team planning`);
         }
         if (repoPath) {
-            const analystModel = config.analystModel || "sonnet";
-            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 analystModel = config.analystModel || cliModel;
+            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 +751,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/dist/spawner.js

@@ -182,9 +182,9 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         // Target repository
         TARGET_REPO: task.githubRepo || "",
         GITHUB_REPO: task.githubRepo || "",
-        // Worker model (CLAUDE_MODEL is legacy compat for manager entrypoint)
-        WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || "sonnet"),
-        CLAUDE_MODEL: task.workerProvider === "anthropic" ? (task.workerModel || "sonnet") : "sonnet",
+        // Worker model — comes from task or org settings, no hardcoded fallbacks
+        WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || ""),
+        CLAUDE_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || ""),
         // Jira credentials (from org Secrets Manager via /api/agent/claim)
         JIRA_BASE_URL: credentials?.jiraBaseUrl || "",
         JIRA_EMAIL: credentials?.jiraEmail || "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workermill/agent",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "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",