claude-flow 3.7.0-alpha.77 → 3.7.0-alpha.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.77",
+  "version": "3.7.0-alpha.78",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/init/claudemd-generator.js

@@ -15,6 +15,7 @@ function behavioralRules() {
 - NEVER save working files or tests to root — use \`/src\`, \`/tests\`, \`/docs\`, \`/config\`, \`/scripts\`
 - ALWAYS read a file before editing it
 - NEVER commit secrets, credentials, or .env files
+- NEVER add a \`Co-Authored-By\` trailer to user commits unless this project's \`.claude/settings.json\` has \`attribution.commit\` set (#2078). The Claude Code Bash tool may suggest one in its default commit-message template — ignore it. \`Co-Authored-By\` is semantic authorship attribution under git/GitHub convention; the tool is the facilitator, not a co-author.
 - Keep files under 500 lines
 - Validate input at system boundaries`;
 }

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-execute-core.js

@@ -60,14 +60,31 @@ export async function callAnthropicMessages(input) {
     const explicitProvider = (process.env.RUFLO_PROVIDER || '').toLowerCase();
     const ollamaKey = process.env.OLLAMA_API_KEY;
     const anthropicKey = process.env.ANTHROPIC_API_KEY;
-    const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !!ollamaKey);
+    // #2042 — OpenRouter is an OpenAI-compat endpoint that fronts dozens of
+    // providers. Reporter (@ummcke00) had `providers.openrouter.apiKey` in
+    // their config.yaml but agent_execute hardcoded Anthropic. Detect via
+    // explicit RUFLO_PROVIDER=openrouter OR presence of OPENROUTER_API_KEY
+    // when no Anthropic key is available (same precedence as the Ollama
+    // branch above).
+    const openrouterKey = process.env.OPENROUTER_API_KEY;
+    const useOpenRouter = explicitProvider === 'openrouter' || (!anthropicKey && !!openrouterKey);
+    const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !!ollamaKey && !openrouterKey);
+    if (useOpenRouter && openrouterKey) {
+        return callOpenAICompat({
+            ...input,
+            apiKey: openrouterKey,
+            baseUrl: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api',
+            providerLabel: 'openrouter',
+            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || 'anthropic/claude-3.5-sonnet',
+        });
+    }
     if (useOllama && ollamaKey) {
         return callOllamaCompat({ ...input, apiKey: ollamaKey });
     }
     if (!anthropicKey) {
         return {
             success: false,
-            error: 'No LLM provider configured. Set ANTHROPIC_API_KEY (Tier-3) or OLLAMA_API_KEY (Tier-2 Ollama Cloud — see issue #1725).',
+            error: 'No LLM provider configured. Set ANTHROPIC_API_KEY (Tier-3), OPENROUTER_API_KEY (#2042), or OLLAMA_API_KEY (Tier-2 — #1725).',
         };
     }
     const model = input.model || DEFAULT_ANTHROPIC_MODEL;
@@ -202,6 +219,88 @@ async function callOllamaCompat(input) {
         };
     }
 }
+/**
+ * Generic OpenAI-compat caller for OpenRouter and other OpenAI-shaped
+ * endpoints. #2042 — reporter (@ummcke00) configured OpenRouter via
+ * config.yaml but agent_execute hardcoded the Anthropic fetch. This is
+ * the same shape as `callOllamaCompat` but routes to a configurable
+ * baseUrl + sends an OpenRouter-friendly default model when none is
+ * specified. Logical model names (haiku/sonnet/opus) pass through —
+ * OpenRouter accepts vendor-prefixed names like `anthropic/claude-3.5-sonnet`.
+ */
+async function callOpenAICompat(input) {
+    const model = resolveOpenAICompatModel(input.model, input.defaultModel);
+    const startedAt = Date.now();
+    const base = input.baseUrl.replace(/\/+$/, '');
+    const url = `${base}/v1/chat/completions`;
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
+        const messages = [];
+        if (input.systemPrompt)
+            messages.push({ role: 'system', content: input.systemPrompt });
+        messages.push({ role: 'user', content: input.prompt });
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${input.apiKey}`,
+                'content-type': 'application/json',
+                // OpenRouter convention: identify the integrating app for analytics
+                // and rate-limit tiering. Harmless on other OpenAI-compat backends.
+                'HTTP-Referer': 'https://github.com/ruvnet/ruflo',
+                'X-Title': 'Ruflo',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: input.maxTokens || 1024,
+                temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
+                messages,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '<unreadable error body>');
+            return { success: false, model, error: `${input.providerLabel} API error ${res.status}: ${errText.slice(0, 400)}` };
+        }
+        const data = await res.json();
+        const textOut = data.choices?.[0]?.message?.content ?? '';
+        const usage = data.usage ?? {};
+        return {
+            success: true,
+            model: data.model || model,
+            messageId: data.id,
+            stopReason: data.choices?.[0]?.finish_reason ?? 'end_turn',
+            output: textOut,
+            usage: {
+                inputTokens: usage.prompt_tokens ?? 0,
+                outputTokens: usage.completion_tokens ?? 0,
+                totalTokens: usage.total_tokens ?? 0,
+            },
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            model,
+            error: err instanceof Error ? err.message : String(err),
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+function resolveOpenAICompatModel(input, fallback) {
+    if (!input)
+        return fallback;
+    // Logical Claude names → OpenRouter Anthropic-vendored names
+    if (input === 'haiku')
+        return 'anthropic/claude-3.5-haiku';
+    if (input === 'sonnet' || input === 'inherit')
+        return 'anthropic/claude-3.5-sonnet';
+    if (input === 'opus')
+        return 'anthropic/claude-3-opus';
+    return input;
+}
 function resolveOllamaModel(input) {
     const DEFAULT = 'gpt-oss:120b-cloud';
     if (!input)
@@ -232,15 +331,6 @@ export function resolveAnthropicModel(input) {
     return input;
 }
 export async function executeAgentTask(input) {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-        return {
-            success: false,
-            agentId: input.agentId,
-            error: 'ANTHROPIC_API_KEY not set in environment',
-            remediation: 'Set the env var and re-run. The key is read at call time.',
-        };
-    }
     const store = loadAgentStore();
     const agent = store.agents[input.agentId];
     if (!agent)
@@ -256,73 +346,50 @@ export async function executeAgentTask(input) {
     agent.taskCount = (agent.taskCount || 0) + 1;
     saveAgentStore(store);
     const startedAt = Date.now();
-    try {
-        const controller = new AbortController();
-        const timeoutMs = input.timeoutMs || 60000;
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const res = await fetch('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'x-api-key': apiKey,
-                'anthropic-version': '2023-06-01',
-                'content-type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: anthropicModel,
-                max_tokens: input.maxTokens || 1024,
-                temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: input.prompt }],
-            }),
-            signal: controller.signal,
-        });
-        clearTimeout(timer);
-        if (!res.ok) {
-            const errText = await res.text().catch(() => '<unreadable error body>');
-            agent.status = 'idle';
-            saveAgentStore(store);
-            return {
-                success: false,
-                agentId: input.agentId,
-                model: anthropicModel,
-                error: `Anthropic API error ${res.status}: ${errText.slice(0, 400)}`,
-            };
-        }
-        const data = await res.json();
-        const textOut = data.content
-            .filter(c => c.type === 'text' && typeof c.text === 'string')
-            .map(c => c.text)
-            .join('');
-        const result = {
+    // #2042 — delegate to callAnthropicMessages so the v3 provider router
+    // (Anthropic / Ollama / OpenRouter) governs which backend is hit. The
+    // previous inline `fetch('https://api.anthropic.com/...')` bypassed
+    // the router entirely and forced an ANTHROPIC_API_KEY error for every
+    // non-Anthropic deployment. Reporter (@ummcke00) had OpenRouter
+    // configured but the bypass made the agent unreachable.
+    const result = await callAnthropicMessages({
+        model: anthropicModel,
+        prompt: input.prompt,
+        systemPrompt,
+        maxTokens: input.maxTokens,
+        temperature: input.temperature,
+        timeoutMs: input.timeoutMs,
+    });
+    agent.status = 'idle';
+    if (result.success) {
+        const out = {
             success: true,
             agentId: input.agentId,
-            messageId: data.id,
-            model: data.model,
-            stopReason: data.stop_reason,
-            output: textOut,
-            usage: {
-                inputTokens: data.usage.input_tokens,
-                outputTokens: data.usage.output_tokens,
-                totalTokens: data.usage.input_tokens + data.usage.output_tokens,
-            },
-            durationMs: Date.now() - startedAt,
+            messageId: result.messageId,
+            model: result.model,
+            stopReason: result.stopReason,
+            output: result.output,
+            usage: result.usage,
+            durationMs: result.durationMs ?? Date.now() - startedAt,
         };
-        agent.status = 'idle';
-        agent.lastResult = result;
-        saveAgentStore(store);
-        return result;
-    }
-    catch (err) {
-        agent.status = 'idle';
+        agent.lastResult = out;
         saveAgentStore(store);
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            success: false,
-            agentId: input.agentId,
-            model: anthropicModel,
-            error: `agent_execute failed: ${msg}`,
-            durationMs: Date.now() - startedAt,
-        };
+        return out;
     }
+    saveAgentStore(store);
+    // No-provider-configured error → surface the same actionable message
+    // the router built, with a #2042-aware remediation pointer.
+    const noProvider = (result.error || '').includes('No LLM provider configured');
+    return {
+        success: false,
+        agentId: input.agentId,
+        model: anthropicModel,
+        error: result.error || 'agent_execute failed',
+        durationMs: result.durationMs ?? Date.now() - startedAt,
+        ...(noProvider && {
+            remediation: 'Set one of ANTHROPIC_API_KEY, OPENROUTER_API_KEY (+ optional OPENROUTER_BASE_URL), or OLLAMA_API_KEY. ' +
+                'Or set RUFLO_PROVIDER=openrouter|ollama to force a specific provider.',
+        }),
+    };
 }
 //# sourceMappingURL=agent-execute-core.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.77",
+  "version": "3.7.0-alpha.78",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",