agentic-flow 1.10.1 → 2.0.0-alpha

package/agentic-flow/dist/agents/claudeFlowAgent.js

@@ -0,0 +1,116 @@
+// Agent with Claude Flow memory and coordination capabilities
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { logger } from '../utils/logger.js';
+import { withRetry } from '../utils/retry.js';
+import { toolConfig } from '../config/tools.js';
+import { getMemoryConfig, getSwarmConfig } from '../config/claudeFlow.js';
+/**
+ * Execute agent with Claude Flow memory and coordination
+ */
+export async function claudeFlowAgent(agentName, systemPrompt, input, options = {}) {
+    const { enableMemory = true, enableCoordination = false, memoryNamespace, swarmTopology = 'mesh', onStream } = options;
+    const startTime = Date.now();
+    logger.info('Starting Claude Flow agent', {
+        agentName,
+        input: input.substring(0, 100),
+        enableMemory,
+        enableCoordination
+    });
+    // Prepare memory context if enabled
+    let memoryContext = '';
+    if (enableMemory) {
+        const memoryConfig = getMemoryConfig(memoryNamespace || agentName);
+        memoryContext = `
+
+You have access to persistent memory via claude-flow tools:
+- Store: mcp__claude-flow__memory_usage with action="store", namespace="${memoryConfig.namespace}"
+- Retrieve: mcp__claude-flow__memory_usage with action="retrieve", namespace="${memoryConfig.namespace}"
+- Search: mcp__claude-flow__memory_search with pattern="search query"
+
+Use memory to persist important information across conversations.`;
+    }
+    // Prepare coordination context if enabled
+    let coordinationContext = '';
+    if (enableCoordination) {
+        const swarmConfig = getSwarmConfig(swarmTopology);
+        coordinationContext = `
+
+You have access to swarm coordination via claude-flow tools:
+- Init swarm: mcp__claude-flow__swarm_init with topology="${swarmConfig.topology}"
+- Spawn agent: mcp__claude-flow__agent_spawn with type="researcher|coder|analyst"
+- Orchestrate: mcp__claude-flow__task_orchestrate with task="description"
+- Check status: mcp__claude-flow__swarm_status
+
+Use coordination for complex multi-agent tasks.`;
+    }
+    const enhancedSystemPrompt = `${systemPrompt}${memoryContext}${coordinationContext}`;
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: enhancedSystemPrompt,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content
+                    ?.map((c) => (c.type === 'text' ? c.text : ''))
+                    .join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Claude Flow agent completed', {
+            agentName,
+            duration,
+            outputLength: output.length,
+            memoryUsed: enableMemory,
+            coordinationUsed: enableCoordination
+        });
+        return { output };
+    });
+}
+/**
+ * Example: Memory-enabled research agent
+ */
+export async function memoryResearchAgent(topic, onStream) {
+    return claudeFlowAgent('memory-researcher', `You are a research agent with persistent memory.
+
+Research the given topic thoroughly and store key findings in memory for future reference.
+Use memory_usage tool to store important facts, insights, and references.`, `Research topic: ${topic}`, {
+        enableMemory: true,
+        enableCoordination: false,
+        onStream
+    });
+}
+/**
+ * Example: Coordination-enabled orchestrator agent
+ */
+export async function orchestratorAgent(task, onStream) {
+    return claudeFlowAgent('orchestrator', `You are an orchestration agent that coordinates multiple specialized agents.
+
+Break down complex tasks and delegate to specialized agents using swarm coordination.
+Use swarm_init, agent_spawn, and task_orchestrate tools to manage the workflow.`, `Orchestrate task: ${task}`, {
+        enableMemory: true,
+        enableCoordination: true,
+        swarmTopology: 'hierarchical',
+        onStream
+    });
+}
+/**
+ * Example: Full-featured agent with memory and coordination
+ */
+export async function hybridAgent(task, agentName = 'hybrid', systemPrompt = 'You are a versatile agent with memory and coordination capabilities.', onStream) {
+    return claudeFlowAgent(agentName, systemPrompt, task, {
+        enableMemory: true,
+        enableCoordination: true,
+        swarmTopology: 'mesh',
+        onStream
+    });
+}
+//# sourceMappingURL=claudeFlowAgent.js.map

package/agentic-flow/dist/agents/claudeFlowAgent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeFlowAgent.js","sourceRoot":"","sources":["../../src/agents/claudeFlowAgent.ts"],"names":[],"mappings":"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","sourcesContent":["// Agent with Claude Flow memory and coordination capabilities\nimport { query } from '@anthropic-ai/claude-agent-sdk';\nimport { logger } from '../utils/logger.js';\nimport { withRetry } from '../utils/retry.js';\nimport { toolConfig } from '../config/tools.js';\nimport { getMemoryConfig, getSwarmConfig } from '../config/claudeFlow.js';\n\nexport interface ClaudeFlowAgentOptions {\n  enableMemory?: boolean;\n  enableCoordination?: boolean;\n  memoryNamespace?: string;\n  swarmTopology?: 'hierarchical' | 'mesh' | 'ring' | 'star';\n  onStream?: (chunk: string) => void;\n}\n\n/**\n * Execute agent with Claude Flow memory and coordination\n */\nexport async function claudeFlowAgent(\n  agentName: string,\n  systemPrompt: string,\n  input: string,\n  options: ClaudeFlowAgentOptions = {}\n) {\n  const {\n    enableMemory = true,\n    enableCoordination = false,\n    memoryNamespace,\n    swarmTopology = 'mesh',\n    onStream\n  } = options;\n\n  const startTime = Date.now();\n  logger.info('Starting Claude Flow agent', {\n    agentName,\n    input: input.substring(0, 100),\n    enableMemory,\n    enableCoordination\n  });\n\n  // Prepare memory context if enabled\n  let memoryContext = '';\n  if (enableMemory) {\n    const memoryConfig = getMemoryConfig(memoryNamespace || agentName);\n    memoryContext = `\n\nYou have access to persistent memory via claude-flow tools:\n- Store: mcp__claude-flow__memory_usage with action=\"store\", namespace=\"${memoryConfig.namespace}\"\n- Retrieve: mcp__claude-flow__memory_usage with action=\"retrieve\", namespace=\"${memoryConfig.namespace}\"\n- Search: mcp__claude-flow__memory_search with pattern=\"search query\"\n\nUse memory to persist important information across conversations.`;\n  }\n\n  // Prepare coordination context if enabled\n  let coordinationContext = '';\n  if (enableCoordination) {\n    const swarmConfig = getSwarmConfig(swarmTopology);\n    coordinationContext = `\n\nYou have access to swarm coordination via claude-flow tools:\n- Init swarm: mcp__claude-flow__swarm_init with topology=\"${swarmConfig.topology}\"\n- Spawn agent: mcp__claude-flow__agent_spawn with type=\"researcher|coder|analyst\"\n- Orchestrate: mcp__claude-flow__task_orchestrate with task=\"description\"\n- Check status: mcp__claude-flow__swarm_status\n\nUse coordination for complex multi-agent tasks.`;\n  }\n\n  const enhancedSystemPrompt = `${systemPrompt}${memoryContext}${coordinationContext}`;\n\n  return withRetry(async () => {\n    const result = query({\n      prompt: input,\n      options: {\n        systemPrompt: enhancedSystemPrompt,\n        ...toolConfig\n      }\n    });\n\n    let output = '';\n    for await (const msg of result) {\n      if (msg.type === 'assistant') {\n        const chunk = msg.message.content\n          ?.map((c: any) => (c.type === 'text' ? c.text : ''))\n          .join('') || '';\n        output += chunk;\n        if (onStream && chunk) {\n          onStream(chunk);\n        }\n      }\n    }\n\n    const duration = Date.now() - startTime;\n    logger.info('Claude Flow agent completed', {\n      agentName,\n      duration,\n      outputLength: output.length,\n      memoryUsed: enableMemory,\n      coordinationUsed: enableCoordination\n    });\n\n    return { output };\n  });\n}\n\n/**\n * Example: Memory-enabled research agent\n */\nexport async function memoryResearchAgent(topic: string, onStream?: (chunk: string) => void) {\n  return claudeFlowAgent(\n    'memory-researcher',\n    `You are a research agent with persistent memory.\n\nResearch the given topic thoroughly and store key findings in memory for future reference.\nUse memory_usage tool to store important facts, insights, and references.`,\n    `Research topic: ${topic}`,\n    {\n      enableMemory: true,\n      enableCoordination: false,\n      onStream\n    }\n  );\n}\n\n/**\n * Example: Coordination-enabled orchestrator agent\n */\nexport async function orchestratorAgent(task: string, onStream?: (chunk: string) => void) {\n  return claudeFlowAgent(\n    'orchestrator',\n    `You are an orchestration agent that coordinates multiple specialized agents.\n\nBreak down complex tasks and delegate to specialized agents using swarm coordination.\nUse swarm_init, agent_spawn, and task_orchestrate tools to manage the workflow.`,\n    `Orchestrate task: ${task}`,\n    {\n      enableMemory: true,\n      enableCoordination: true,\n      swarmTopology: 'hierarchical',\n      onStream\n    }\n  );\n}\n\n/**\n * Example: Full-featured agent with memory and coordination\n */\nexport async function hybridAgent(\n  task: string,\n  agentName: string = 'hybrid',\n  systemPrompt: string = 'You are a versatile agent with memory and coordination capabilities.',\n  onStream?: (chunk: string) => void\n) {\n  return claudeFlowAgent(\n    agentName,\n    systemPrompt,\n    task,\n    {\n      enableMemory: true,\n      enableCoordination: true,\n      swarmTopology: 'mesh',\n      onStream\n    }\n  );\n}\n"]}

package/agentic-flow/dist/agents/codeReviewAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeReviewAgent.d.ts","sourceRoot":"","sources":["../../src/agents/codeReviewAgent.ts"],"names":[],"mappings":"AAMA,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;GAiCtF"}

package/agentic-flow/dist/agents/codeReviewAgent.js

@@ -0,0 +1,35 @@
+// src/agents/codeReviewAgent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { toolConfig } from "../config/tools.js";
+export async function codeReviewAgent(input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting code review agent', { input: input.substring(0, 100) });
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: `You review diffs and point out risks, complexity, and tests to add.`,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Code review agent completed', {
+            duration,
+            outputLength: output.length
+        });
+        return { output };
+    });
+}
+//# sourceMappingURL=codeReviewAgent.js.map

package/agentic-flow/dist/agents/codeReviewAgent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeReviewAgent.js","sourceRoot":"","sources":["../../src/agents/codeReviewAgent.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAa,EAAE,QAAkC;IACrF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IAE9E,OAAO,SAAS,CAAC,KAAK,IAAI,EAAE;QAC1B,MAAM,MAAM,GAAG,KAAK,CAAC;YACnB,MAAM,EAAE,KAAK;YACb,OAAO,EAAE;gBACP,YAAY,EAAE,qEAAqE;gBACnF,GAAG,UAAU;aACd;SACF,CAAC,CAAC;QAEH,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YAC/B,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBAC7B,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;gBACnG,MAAM,IAAI,KAAK,CAAC;gBAEhB,IAAI,QAAQ,IAAI,KAAK,EAAE,CAAC;oBACtB,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAClB,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE;YACzC,QAAQ;YACR,YAAY,EAAE,MAAM,CAAC,MAAM;SAC5B,CAAC,CAAC;QAEH,OAAO,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// src/agents/codeReviewAgent.ts\nimport { query } from \"@anthropic-ai/claude-agent-sdk\";\nimport { logger } from \"../utils/logger.js\";\nimport { withRetry } from \"../utils/retry.js\";\nimport { toolConfig } from \"../config/tools.js\";\n\nexport async function codeReviewAgent(input: string, onStream?: (chunk: string) => void) {\n  const startTime = Date.now();\n  logger.info('Starting code review agent', { input: input.substring(0, 100) });\n\n  return withRetry(async () => {\n    const result = query({\n      prompt: input,\n      options: {\n        systemPrompt: `You review diffs and point out risks, complexity, and tests to add.`,\n        ...toolConfig\n      }\n    });\n\n    let output = '';\n    for await (const msg of result) {\n      if (msg.type === 'assistant') {\n        const chunk = msg.message.content?.map((c: any) => c.type === 'text' ? c.text : '').join('') || '';\n        output += chunk;\n\n        if (onStream && chunk) {\n          onStream(chunk);\n        }\n      }\n    }\n\n    const duration = Date.now() - startTime;\n    logger.info('Code review agent completed', {\n      duration,\n      outputLength: output.length\n    });\n\n    return { output };\n  });\n}\n"]}

package/agentic-flow/dist/agents/dataAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataAgent.d.ts","sourceRoot":"","sources":["../../src/agents/dataAgent.ts"],"names":[],"mappings":"AAMA,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;GAiChF"}

package/agentic-flow/dist/agents/dataAgent.js

@@ -0,0 +1,35 @@
+// src/agents/dataAgent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { toolConfig } from "../config/tools.js";
+export async function dataAgent(input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting data agent', { input: input.substring(0, 100) });
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: `You analyze tabular data and produce a short brief with 3 key stats and 1 risk.`,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Data agent completed', {
+            duration,
+            outputLength: output.length
+        });
+        return { output };
+    });
+}
+//# sourceMappingURL=dataAgent.js.map

package/agentic-flow/dist/agents/dataAgent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataAgent.js","sourceRoot":"","sources":["../../src/agents/dataAgent.ts"],"names":[],"mappings":"AAAA,0BAA0B;AAC1B,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,KAAa,EAAE,QAAkC;IAC/E,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IAEvE,OAAO,SAAS,CAAC,KAAK,IAAI,EAAE;QAC1B,MAAM,MAAM,GAAG,KAAK,CAAC;YACnB,MAAM,EAAE,KAAK;YACb,OAAO,EAAE;gBACP,YAAY,EAAE,iFAAiF;gBAC/F,GAAG,UAAU;aACd;SACF,CAAC,CAAC;QAEH,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YAC/B,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBAC7B,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;gBACnG,MAAM,IAAI,KAAK,CAAC;gBAEhB,IAAI,QAAQ,IAAI,KAAK,EAAE,CAAC;oBACtB,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAClB,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE;YAClC,QAAQ;YACR,YAAY,EAAE,MAAM,CAAC,MAAM;SAC5B,CAAC,CAAC;QAEH,OAAO,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// src/agents/dataAgent.ts\nimport { query } from \"@anthropic-ai/claude-agent-sdk\";\nimport { logger } from \"../utils/logger.js\";\nimport { withRetry } from \"../utils/retry.js\";\nimport { toolConfig } from \"../config/tools.js\";\n\nexport async function dataAgent(input: string, onStream?: (chunk: string) => void) {\n  const startTime = Date.now();\n  logger.info('Starting data agent', { input: input.substring(0, 100) });\n\n  return withRetry(async () => {\n    const result = query({\n      prompt: input,\n      options: {\n        systemPrompt: `You analyze tabular data and produce a short brief with 3 key stats and 1 risk.`,\n        ...toolConfig\n      }\n    });\n\n    let output = '';\n    for await (const msg of result) {\n      if (msg.type === 'assistant') {\n        const chunk = msg.message.content?.map((c: any) => c.type === 'text' ? c.text : '').join('') || '';\n        output += chunk;\n\n        if (onStream && chunk) {\n          onStream(chunk);\n        }\n      }\n    }\n\n    const duration = Date.now() - startTime;\n    logger.info('Data agent completed', {\n      duration,\n      outputLength: output.length\n    });\n\n    return { output };\n  });\n}\n"]}

package/agentic-flow/dist/agents/directApiAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directApiAgent.d.ts","sourceRoot":"","sources":["../../src/agents/directApiAgent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAwN1D;;;GAGG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GACjC,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAmM5C"}

package/agentic-flow/dist/agents/directApiAgent.js

@@ -0,0 +1,383 @@
+// Direct API agent with multi-provider support (Anthropic, OpenRouter, Gemini)
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from '../utils/logger.js';
+import { withRetry } from '../utils/retry.js';
+import { execSync } from 'child_process';
+import { ModelRouter } from '../router/router.js';
+// Lazy initialize clients
+let anthropic = null;
+let router = null;
+function getAnthropicClient() {
+    if (!anthropic) {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        // Validate API key format
+        if (!apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required but not set');
+        }
+        if (!apiKey.startsWith('sk-ant-')) {
+            throw new Error(`Invalid ANTHROPIC_API_KEY format. Expected format: sk-ant-...\n` +
+                `Got: ${apiKey.substring(0, 10)}...\n\n` +
+                `Please check your API key at: https://console.anthropic.com/settings/keys`);
+        }
+        anthropic = new Anthropic({ apiKey });
+    }
+    return anthropic;
+}
+function getRouter() {
+    if (!router) {
+        // Router will now auto-create config from environment variables if no file exists
+        router = new ModelRouter();
+    }
+    return router;
+}
+function getCurrentProvider() {
+    // Determine provider from environment
+    if (process.env.PROVIDER === 'gemini' || process.env.USE_GEMINI === 'true') {
+        return 'gemini';
+    }
+    if (process.env.PROVIDER === 'openrouter' || process.env.USE_OPENROUTER === 'true') {
+        return 'openrouter';
+    }
+    if (process.env.PROVIDER === 'onnx' || process.env.USE_ONNX === 'true') {
+        return 'onnx';
+    }
+    return 'anthropic';
+}
+// Define claude-flow tools as native Anthropic tool definitions
+const claudeFlowTools = [
+    {
+        name: 'memory_store',
+        description: 'Store a value in persistent memory with optional namespace and TTL',
+        input_schema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                value: { type: 'string', description: 'Value to store' },
+                namespace: { type: 'string', description: 'Memory namespace', default: 'default' },
+                ttl: { type: 'number', description: 'Time-to-live in seconds' }
+            },
+            required: ['key', 'value']
+        }
+    },
+    {
+        name: 'memory_retrieve',
+        description: 'Retrieve a value from persistent memory',
+        input_schema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Memory namespace', default: 'default' }
+            },
+            required: ['key']
+        }
+    },
+    {
+        name: 'memory_search',
+        description: 'Search for keys matching a pattern in memory',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Search pattern (supports wildcards)' },
+                namespace: { type: 'string', description: 'Memory namespace to search in' },
+                limit: { type: 'number', description: 'Maximum results to return', default: 10 }
+            },
+            required: ['pattern']
+        }
+    },
+    {
+        name: 'swarm_init',
+        description: 'Initialize a multi-agent swarm with specified topology',
+        input_schema: {
+            type: 'object',
+            properties: {
+                topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'], description: 'Swarm topology' },
+                maxAgents: { type: 'number', description: 'Maximum number of agents', default: 8 },
+                strategy: { type: 'string', enum: ['balanced', 'specialized', 'adaptive'], description: 'Agent distribution strategy', default: 'balanced' }
+            },
+            required: ['topology']
+        }
+    },
+    {
+        name: 'agent_spawn',
+        description: 'Spawn a new agent in the swarm',
+        input_schema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'], description: 'Agent type' },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' },
+                name: { type: 'string', description: 'Custom agent name' }
+            },
+            required: ['type']
+        }
+    },
+    {
+        name: 'task_orchestrate',
+        description: 'Orchestrate a complex task across the swarm',
+        input_schema: {
+            type: 'object',
+            properties: {
+                task: { type: 'string', description: 'Task description or instructions' },
+                strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy', default: 'adaptive' },
+                priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], description: 'Task priority', default: 'medium' },
+                maxAgents: { type: 'number', description: 'Maximum agents to use for this task' }
+            },
+            required: ['task']
+        }
+    },
+    {
+        name: 'swarm_status',
+        description: 'Get current swarm status and metrics',
+        input_schema: {
+            type: 'object',
+            properties: {
+                verbose: { type: 'boolean', description: 'Include detailed metrics', default: false }
+            }
+        }
+    }
+];
+// Execute tool calls using claude-flow CLI
+async function executeToolCall(toolName, toolInput) {
+    try {
+        logger.info('Executing tool', { toolName, input: toolInput });
+        switch (toolName) {
+            case 'memory_store': {
+                const { key, value, namespace = 'default', ttl } = toolInput;
+                const cmd = `npx claude-flow@alpha memory store "${key}" "${value}" --namespace "${namespace}"${ttl ? ` --ttl ${ttl}` : ''}`;
+                const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+                logger.info('Memory stored', { key, namespace });
+                return `✅ Stored successfully\n📝 Key: ${key}\n📦 Namespace: ${namespace}\n💾 Size: ${value.length} bytes`;
+            }
+            case 'memory_retrieve': {
+                const { key, namespace = 'default' } = toolInput;
+                const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                logger.info('Memory retrieved', { key });
+                return `✅ Retrieved:\n${result}`;
+            }
+            case 'memory_search': {
+                const { pattern, namespace, limit = 10 } = toolInput;
+                const cmd = `npx claude-flow@alpha memory search "${pattern}"${namespace ? ` --namespace "${namespace}"` : ''} --limit ${limit}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `🔍 Search results:\n${result}`;
+            }
+            case 'swarm_init': {
+                const { topology, maxAgents = 8, strategy = 'balanced' } = toolInput;
+                const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `🚀 Swarm initialized:\n${result}`;
+            }
+            case 'agent_spawn': {
+                const { type, capabilities, name } = toolInput;
+                const capStr = capabilities ? ` --capabilities "${capabilities.join(',')}"` : '';
+                const nameStr = name ? ` --name "${name}"` : '';
+                const cmd = `npx claude-flow@alpha agent spawn --type ${type}${capStr}${nameStr}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `🤖 Agent spawned:\n${result}`;
+            }
+            case 'task_orchestrate': {
+                const { task, strategy = 'adaptive', priority = 'medium', maxAgents } = toolInput;
+                const maxStr = maxAgents ? ` --max-agents ${maxAgents}` : '';
+                const cmd = `npx claude-flow@alpha task orchestrate "${task}" --strategy ${strategy} --priority ${priority}${maxStr}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `⚡ Task orchestrated:\n${result}`;
+            }
+            case 'swarm_status': {
+                const { verbose = false } = toolInput;
+                const cmd = `npx claude-flow@alpha swarm status${verbose ? ' --verbose' : ''}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `📊 Swarm status:\n${result}`;
+            }
+            default:
+                throw new Error(`Unknown tool: ${toolName}`);
+        }
+    }
+    catch (error) {
+        logger.error('Tool execution failed', { toolName, error: error.message });
+        return `❌ Tool execution failed: ${error.message}`;
+    }
+}
+/**
+ * Direct API agent using Anthropic SDK with native tool calling
+ * Bypasses Claude Agent SDK subprocess issues entirely
+ */
+export async function directApiAgent(agent, input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting direct API agent', {
+        agent: agent.name,
+        input: input.substring(0, 100)
+    });
+    return withRetry(async () => {
+        const messages = [
+            { role: 'user', content: input }
+        ];
+        let finalOutput = '';
+        let toolUseCount = 0;
+        const maxToolUses = 10; // Prevent infinite loops
+        // Agentic loop: keep calling API until no more tool uses
+        while (toolUseCount < maxToolUses) {
+            logger.debug('API call iteration', { toolUseCount, messagesLength: messages.length });
+            const provider = getCurrentProvider();
+            let response;
+            try {
+                // Use router for non-Anthropic providers
+                if (provider === 'gemini' || provider === 'openrouter') {
+                    const routerInstance = getRouter();
+                    // Convert Anthropic messages format to router format
+                    const routerMessages = messages.map(msg => ({
+                        role: msg.role,
+                        content: typeof msg.content === 'string' ? msg.content : msg.content.map((block) => {
+                            if ('text' in block)
+                                return { type: 'text', text: block.text };
+                            if ('tool_use_id' in block)
+                                return {
+                                    type: 'tool_result',
+                                    content: block.content
+                                };
+                            if ('name' in block && 'input' in block)
+                                return {
+                                    type: 'tool_use',
+                                    id: block.id,
+                                    name: block.name,
+                                    input: block.input
+                                };
+                            return { type: 'text', text: '' };
+                        }).filter((b) => b.type === 'text' || b.type === 'tool_use' || b.type === 'tool_result')
+                    }));
+                    // Add system prompt as first message if needed
+                    const messagesWithSystem = agent.systemPrompt
+                        ? [{ role: 'system', content: agent.systemPrompt }, ...routerMessages]
+                        : routerMessages;
+                    const params = {
+                        model: provider === 'gemini'
+                            ? (process.env.COMPLETION_MODEL || 'gemini-2.0-flash-exp')
+                            : (process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat'),
+                        messages: messagesWithSystem,
+                        maxTokens: 8192,
+                        temperature: 0.7
+                    };
+                    const routerResponse = await routerInstance.chat(params);
+                    // Convert router response to Anthropic format
+                    response = {
+                        id: routerResponse.id,
+                        model: routerResponse.model,
+                        stop_reason: routerResponse.stopReason,
+                        content: routerResponse.content.map(block => {
+                            if (block.type === 'text')
+                                return { type: 'text', text: block.text || '' };
+                            if (block.type === 'tool_use')
+                                return {
+                                    type: 'tool_use',
+                                    id: block.id || '',
+                                    name: block.name || '',
+                                    input: block.input || {}
+                                };
+                            return { type: 'text', text: '' };
+                        })
+                    };
+                }
+                else {
+                    // Use Anthropic client for Anthropic provider
+                    const client = getAnthropicClient();
+                    response = await client.messages.create({
+                        model: process.env.COMPLETION_MODEL || 'claude-sonnet-4-5-20250929',
+                        max_tokens: 8192,
+                        system: agent.systemPrompt || 'You are a helpful AI assistant.',
+                        messages,
+                        tools: claudeFlowTools
+                    });
+                }
+            }
+            catch (error) {
+                // Enhance authentication errors with helpful guidance
+                if (error?.status === 401 || error?.statusCode === 401) {
+                    const providerName = provider === 'gemini' ? 'Google Gemini' : provider === 'openrouter' ? 'OpenRouter' : 'Anthropic';
+                    const apiKey = provider === 'gemini'
+                        ? process.env.GOOGLE_GEMINI_API_KEY
+                        : provider === 'openrouter'
+                            ? process.env.OPENROUTER_API_KEY
+                            : process.env.ANTHROPIC_API_KEY;
+                    throw new Error(`❌ ${providerName} API authentication failed (401)\n\n` +
+                        `Your API key is invalid, expired, or lacks permissions.\n` +
+                        `Current key: ${apiKey?.substring(0, 15)}...\n\n` +
+                        `Please check your ${providerName} API key and update your .env file.\n\n` +
+                        `Alternative providers:\n` +
+                        `  --provider anthropic  (Claude models)\n` +
+                        `  --provider openrouter (100+ models, 99% cost savings)\n` +
+                        `  --provider gemini     (Google models)\n` +
+                        `  --provider onnx       (free local inference)`);
+                }
+                throw error;
+            }
+            logger.debug('API response', {
+                stopReason: response.stop_reason,
+                contentBlocks: response.content.length
+            });
+            // Process response content
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    finalOutput += block.text;
+                    if (onStream) {
+                        onStream(block.text);
+                    }
+                }
+                else if (block.type === 'tool_use') {
+                    toolUseCount++;
+                    logger.info('Tool use requested', {
+                        toolName: block.name,
+                        toolUseId: block.id
+                    });
+                    // Execute the tool
+                    const toolResult = await executeToolCall(block.name, block.input);
+                    // Collect tool result
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: toolResult
+                    });
+                    logger.debug('Tool result collected', {
+                        toolUseId: block.id,
+                        resultLength: toolResult.length
+                    });
+                }
+            }
+            // If there were tool uses, add assistant message and all tool results
+            if (toolResults.length > 0) {
+                // Add assistant message with tool uses
+                messages.push({
+                    role: 'assistant',
+                    content: response.content
+                });
+                // Add all tool results in one user message
+                messages.push({
+                    role: 'user',
+                    content: toolResults
+                });
+                logger.debug('Tool results added to conversation', {
+                    count: toolResults.length
+                });
+            }
+            // Stop if no tool use or end_turn
+            if (response.stop_reason === 'end_turn' || response.content.every((b) => b.type === 'text')) {
+                // Add final assistant message if it has text
+                const textContent = response.content.filter((b) => b.type === 'text');
+                if (textContent.length > 0 && messages[messages.length - 1].role !== 'assistant') {
+                    messages.push({
+                        role: 'assistant',
+                        content: response.content
+                    });
+                }
+                break;
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Direct API agent completed', {
+            agent: agent.name,
+            duration,
+            toolUseCount,
+            outputLength: finalOutput.length
+        });
+        return { output: finalOutput, agent: agent.name };
+    });
+}
+//# sourceMappingURL=directApiAgent.js.map