@workermill/agent 0.3.0 → 0.3.1

package/dist/plan-validator.d.ts

@@ -9,6 +9,7 @@
  * This ensures remote agent plans get the same quality gates as cloud plans,
  * even though the planning prompt runs locally via Claude CLI.
  */
+import { type AIProvider } from "./providers.js";
 export interface PlannedStory {
     id: string;
     title: string;
@@ -76,7 +77,8 @@ export declare function runCriticCli(claudePath: string, model: string, prompt:
 export declare function formatCriticFeedback(critic: CriticResult): string;
 /**
  * Run critic validation on a parsed plan.
+ * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string): Promise<CriticResult | null>;
+export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string, provider?: AIProvider, providerApiKey?: string): Promise<CriticResult | null>;
 export { AUTO_APPROVAL_THRESHOLD };

package/dist/plan-validator.js

@@ -11,6 +11,7 @@
  */
 import { spawn } from "child_process";
 import chalk from "chalk";
+import { generateText } from "./providers.js";
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -245,13 +246,24 @@ function ts() {
 }
 /**
  * Run critic validation on a parsed plan.
+ * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel) {
+export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel, provider, providerApiKey) {
     const criticPrompt = buildCriticPrompt(prd, plan);
-    console.log(`${ts()} ${taskLabel} ${chalk.dim("Running critic validation...")}`);
+    const effectiveProvider = provider || "anthropic";
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`Running critic validation (${effectiveProvider})...`)}`);
     try {
-        const rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        let rawCriticOutput;
+        if (effectiveProvider === "anthropic") {
+            rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        }
+        else {
+            if (!providerApiKey) {
+                throw new Error(`No API key for critic provider "${effectiveProvider}"`);
+            }
+            rawCriticOutput = await generateText(effectiveProvider, model, criticPrompt, providerApiKey, { maxTokens: 4096, temperature: 0.3, timeoutMs: 180_000 });
+        }
         const result = parseCriticResponse(rawCriticOutput);
         const statusIcon = result.score >= AUTO_APPROVAL_THRESHOLD
             ? chalk.green("✓")

package/dist/planner.d.ts

@@ -15,6 +15,7 @@
  * sees the same planning progress as cloud mode.
  */
 import { type AgentConfig } from "./config.js";
+import type { ClaimCredentials } from "./spawner.js";
 export interface PlanningTask {
     id: string;
     summary: string;
@@ -32,4 +33,4 @@ export interface PlanningTask {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export declare function planTask(task: PlanningTask, config: AgentConfig): Promise<boolean>;
+export declare function planTask(task: PlanningTask, config: AgentConfig, credentials?: ClaimCredentials): Promise<boolean>;

package/dist/planner.js

@@ -19,6 +19,7 @@ import { spawn } from "child_process";
 import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
 import { parseExecutionPlan, applyFileCap, serializePlan, runCriticValidation, formatCriticFeedback, AUTO_APPROVAL_THRESHOLD, } from "./plan-validator.js";
+import { generateText } from "./providers.js";
 /** Max Planner-Critic iterations before giving up */
 const MAX_ITERATIONS = 3;
 /** Timestamp prefix */
@@ -228,6 +229,26 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         });
     });
 }
+/**
+ * Resolve the API key for a given provider from claim credentials.
+ * For Ollama, returns the base URL instead of an API key.
+ */
+function resolveProviderApiKey(provider, credentials) {
+    if (!credentials)
+        return undefined;
+    switch (provider) {
+        case "anthropic":
+            return credentials.anthropicApiKey;
+        case "openai":
+            return credentials.openaiApiKey;
+        case "google":
+            return credentials.googleApiKey;
+        case "ollama":
+            return credentials.ollamaBaseUrl || "http://localhost:11434";
+        default:
+            return undefined;
+    }
+}
 /**
  * Run planning for a task with Planner-Critic validation loop.
  *
@@ -240,7 +261,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export async function planTask(task, config) {
+export async function planTask(task, config, credentials) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     console.log(`${ts()} ${taskLabel} Fetching planning prompt...`);
     await postLog(task.id, `${PREFIX} Fetching planning prompt from cloud API...`);
@@ -248,11 +269,15 @@ export async function planTask(task, config) {
     const promptResponse = await api.get("/api/agent/planning-prompt", {
         params: { taskId: task.id },
     });
-    const { prompt: basePrompt, model } = promptResponse.data;
+    const { prompt: basePrompt, model, provider: planningProvider } = promptResponse.data;
     const cliModel = model || "sonnet";
+    const provider = (planningProvider || "anthropic");
+    const isAnthropicPlanning = provider === "anthropic";
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
     const cleanEnv = { ...process.env };
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    // Resolve provider API key for non-Anthropic planning
+    const providerApiKey = resolveProviderApiKey(provider, credentials);
     const startTime = Date.now();
     // PRD for critic validation: use task description, fall back to summary
     const prd = task.description || task.summary;
@@ -265,18 +290,28 @@ export async function planTask(task, config) {
     let totalFileCapTruncations = 0;
     for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
         const iterLabel = MAX_ITERATIONS > 1 ? ` (attempt ${iteration}/${MAX_ITERATIONS})` : "";
+        const providerLabel = `${provider}/${cliModel}`;
         if (iteration > 1) {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI${iterLabel} ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using anthropic/${cliModel}`);
+            console.log(`${ts()} ${taskLabel} Running planner${iterLabel} ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using ${providerLabel}`);
         }
         else {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Starting planning agent using anthropic/${cliModel}`);
+            console.log(`${ts()} ${taskLabel} Running planner ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+            await postLog(task.id, `${PREFIX} Starting planning agent using ${providerLabel}`);
         }
-        // 2a. Run Claude CLI to generate plan
+        // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
         let rawOutput;
         try {
-            rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+            if (isAnthropicPlanning) {
+                rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+            }
+            else {
+                if (!providerApiKey) {
+                    throw new Error(`No API key available for provider "${provider}". Configure it in Settings > Integrations.`);
+                }
+                await postProgress(task.id, "generating_plan", 0, "Generating plan via API...", 0, 0);
+                rawOutput = await generateText(provider, cliModel, currentPrompt, providerApiKey);
+            }
         }
         catch (error) {
             const elapsed = Math.round((Date.now() - startTime) / 1000);
@@ -313,7 +348,7 @@ export async function planTask(task, config) {
         console.log(`${ts()} ${taskLabel} Plan: ${chalk.bold(plan.stories.length)} stories`);
         await postLog(task.id, `${PREFIX} Plan generated: ${plan.stories.length} stories (${formatElapsed(elapsed)}). Running critic validation...`);
         // 2d. Run critic validation
-        const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel);
+        const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel, provider, providerApiKey);
         // Track best plan across iterations
         if (criticResult && criticResult.score > bestScore) {
             bestPlan = plan;

package/dist/poller.js

@@ -7,7 +7,7 @@
 import chalk from "chalk";
 import { api } from "./api.js";
 import { planTask } from "./planner.js";
-import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask } from "./spawner.js";
+import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask, } from "./spawner.js";
 import { AGENT_VERSION } from "./version.js";
 import { selfUpdate, restartAgent } from "./updater.js";
 // Track tasks currently being planned (to avoid double-dispatching)
@@ -76,7 +76,8 @@ async function pollOnce(config) {
  * Handle a task in "planning" status.
  */
 async function handlePlanningTask(task, config) {
-    // Claim the task
+    // Claim the task (also returns org credentials for provider API keys)
+    let credentials;
     try {
         const claimResponse = await api.post("/api/agent/claim", {
             taskId: task.id,
@@ -85,6 +86,7 @@ async function handlePlanningTask(task, config) {
         if (!claimResponse.data.claimed) {
             return; // Another agent or cloud orchestrator claimed it
         }
+        credentials = claimResponse.data.credentials;
     }
     catch {
         return;
@@ -94,7 +96,7 @@ async function handlePlanningTask(task, config) {
     console.log(`${ts()} ${chalk.magenta("◆ PLANNING")} ${taskLabel} ${task.summary.substring(0, 60)}`);
     planningInProgress.add(task.id);
     // Run planning asynchronously (don't block the poll loop)
-    planTask(task, config)
+    planTask(task, config, credentials)
         .then((success) => {
         if (success) {
             console.log(`${ts()} ${chalk.green("✓")} Planning complete for ${taskLabel}`);

package/dist/providers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lightweight HTTP wrappers for text generation across AI providers.
+ *
+ * Used for planning and critic stages when the org's provider is not Anthropic.
+ * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
+ * Streaming is not needed (planning/critic are text-only, result matters).
+ */
+export type AIProvider = "anthropic" | "openai" | "google" | "ollama";
+export interface GenerateTextOptions {
+    maxTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+}
+/**
+ * Generate text from any supported AI provider via direct HTTP API calls.
+ * Returns the raw text response.
+ */
+export declare function generateText(provider: AIProvider, model: string, prompt: string, apiKey: string, options?: GenerateTextOptions): Promise<string>;

package/dist/providers.js

@@ -0,0 +1,118 @@
+/**
+ * Lightweight HTTP wrappers for text generation across AI providers.
+ *
+ * Used for planning and critic stages when the org's provider is not Anthropic.
+ * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
+ * Streaming is not needed (planning/critic are text-only, result matters).
+ */
+import axios from "axios";
+const DEFAULT_MAX_TOKENS = 16384;
+const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes (matches Claude CLI timeout)
+/**
+ * Generate text from any supported AI provider via direct HTTP API calls.
+ * Returns the raw text response.
+ */
+export async function generateText(provider, model, prompt, apiKey, options) {
+    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const temperature = options?.temperature ?? 0.7;
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    switch (provider) {
+        case "anthropic":
+            return generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "openai":
+            return generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "google":
+            return generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        case "ollama":
+            return generateOllama(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
+        default:
+            throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+}
+/**
+ * Anthropic Messages API (for orgs with API key, not CLI).
+ */
+async function generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post("https://api.anthropic.com/v1/messages", {
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [{ role: "user", content: prompt }],
+    }, {
+        headers: {
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+            "Content-Type": "application/json",
+        },
+        timeout: timeoutMs,
+    });
+    const content = response.data?.content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+    }
+    throw new Error("Unexpected Anthropic API response format");
+}
+/**
+ * OpenAI Chat Completions API.
+ */
+async function generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post("https://api.openai.com/v1/chat/completions", {
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [{ role: "user", content: prompt }],
+    }, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        timeout: timeoutMs,
+    });
+    const message = response.data?.choices?.[0]?.message;
+    if (message?.content)
+        return message.content;
+    throw new Error("Unexpected OpenAI API response format");
+}
+/**
+ * Google Generative AI (Gemini) API.
+ */
+async function generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
+    const response = await axios.post(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+        contents: [{ parts: [{ text: prompt }] }],
+        generationConfig: {
+            maxOutputTokens: maxTokens,
+            temperature,
+        },
+    }, {
+        headers: { "Content-Type": "application/json" },
+        timeout: timeoutMs,
+    });
+    const candidate = response.data?.candidates?.[0];
+    const text = candidate?.content?.parts?.[0]?.text;
+    if (text)
+        return text;
+    throw new Error("Unexpected Google AI API response format");
+}
+/**
+ * Ollama Generate API (self-hosted).
+ * `apiKey` is used as the Ollama base URL (e.g. "http://localhost:11434").
+ */
+async function generateOllama(model, prompt, ollamaHost, _maxTokens, temperature, timeoutMs) {
+    const baseUrl = ollamaHost || "http://localhost:11434";
+    const response = await axios.post(`${baseUrl}/api/generate`, {
+        model,
+        prompt,
+        stream: false,
+        options: { temperature },
+    }, {
+        headers: { "Content-Type": "application/json" },
+        timeout: timeoutMs,
+    });
+    const text = response.data?.response;
+    if (text)
+        return text;
+    throw new Error("Unexpected Ollama API response format");
+}

package/dist/spawner.d.ts

@@ -14,6 +14,7 @@ export interface SpawnableTask {
     description: string | null;
     jiraIssueKey: string | null;
     workerModel: string;
+    workerProvider?: string;
     githubRepo: string;
     scmProvider: string;
     skipManagerReview?: boolean;
@@ -34,6 +35,10 @@ export interface ClaimCredentials {
     customerAwsRegion?: string;
     issueTrackerProvider?: string;
     bitbucketEmail?: string;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+    googleApiKey?: string;
+    ollamaBaseUrl?: string;
 }
 /**
  * Spawn a Docker worker container for a task.

package/dist/spawner.js

@@ -193,8 +193,13 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         BITBUCKET_EMAIL: credentials?.bitbucketEmail || "",
         // Task notes from dashboard
         TASK_NOTES: task.taskNotes || "",
-        // Anthropic API key (if available)
-        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+        // AI provider configuration
+        ANTHROPIC_API_KEY: credentials?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || "",
+        WORKER_PROVIDER: task.workerProvider || "anthropic",
+        OPENAI_API_KEY: credentials?.openaiApiKey || "",
+        GOOGLE_API_KEY: credentials?.googleApiKey || "",
+        GOOGLE_GENERATIVE_AI_API_KEY: credentials?.googleApiKey || "",
+        OLLAMA_HOST: credentials?.ollamaBaseUrl || "",
         // Resilience settings from org config
         BLOCKER_MAX_AUTO_RETRIES: String(orgConfig.blockerMaxAutoRetries ?? 3),
         BLOCKER_AUTO_RETRY_ENABLED: orgConfig.blockerAutoRetryEnabled !== false ? "true" : "false",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workermill/agent",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
   "type": "module",
   "main": "./dist/index.js",