@synergenius/flow-weaver 0.22.7 → 0.22.9

package/dist/agent/agent-loop.js

@@ -30,6 +30,8 @@ export async function runAgentLoop(provider, tools, executor, messages, options)
             model: options?.model,
             maxTokens: options?.maxTokens,
             signal,
+            executor,
+            onToolEvent,
         });
         for await (const event of stream) {
             onStreamEvent?.(event);
@@ -51,6 +53,10 @@ export async function runAgentLoop(provider, tools, executor, messages, options)
                     });
                     activeToolNames.delete(event.id);
                     break;
+                case 'tool_result':
+                    // CLI handled tool internally via MCP — count it
+                    toolCallCount++;
+                    break;
                 case 'usage':
                     totalPromptTokens += event.promptTokens;
                     totalCompletionTokens += event.completionTokens;

package/dist/agent/index.d.ts

@@ -2,13 +2,15 @@
  * @synergenius/flow-weaver/agent
  *
  * Provider-agnostic agent loop with MCP bridge for tool execution.
- * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
 export type { StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
 export { runAgentLoop } from './agent-loop.js';
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export type { AnthropicProviderOptions } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
+export type { OpenAICompatProviderOptions } from './providers/openai-compat.js';
 export { createMcpBridge } from './mcp-bridge.js';
 export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
 export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';

package/dist/agent/index.js

@@ -2,13 +2,14 @@
  * @synergenius/flow-weaver/agent
  *
  * Provider-agnostic agent loop with MCP bridge for tool execution.
- * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
 // Agent loop
 export { runAgentLoop } from './agent-loop.js';
 // Providers
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
 // MCP bridge
 export { createMcpBridge } from './mcp-bridge.js';
 // CLI session (warm persistent sessions)

package/dist/agent/providers/claude-cli.js

@@ -23,7 +23,7 @@ export class ClaudeCliProvider {
         this.model = options.model;
         this.mcpConfigPath = options.mcpConfigPath;
         this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
-        this.timeout = options.timeout ?? 120_000;
+        this.timeout = options.timeout ?? 600_000;
     }
     async *stream(messages, tools, options) {
         const model = options?.model ?? this.model;
@@ -34,11 +34,10 @@ export class ClaudeCliProvider {
         let bridge = null;
         let mcpConfigPath = this.mcpConfigPath;
         if (tools.length > 0 && !mcpConfigPath) {
-            // Create a temporary bridge — tool execution is handled by the agent loop,
-            // but we still need to advertise tool definitions to the CLI via MCP.
-            // The bridge executor won't be called because the CLI handles its own tool
-            // loop internally when using MCP tools.
-            bridge = await createMcpBridge(tools, async () => ({ result: 'Not implemented', isError: true }));
+            // Create MCP bridge with real executor so CLI tool calls go through our
+            // safety guards (path traversal, shrink detection, shell blocklist, etc.)
+            const executor = options?.executor ?? (async () => ({ result: 'Tool executor not provided', isError: true }));
+            bridge = await createMcpBridge(tools, executor, options?.onToolEvent);
             mcpConfigPath = bridge.configPath;
         }
         const args = [
@@ -70,10 +69,11 @@ export class ClaudeCliProvider {
                 }, 2000);
             }, { once: true });
         }
-        // Timeout
+        // Timeout — per-request override or provider default
+        const timeout = options?.timeout ?? this.timeout;
         const timer = setTimeout(() => {
             child.kill('SIGTERM');
-        }, this.timeout);
+        }, timeout);
         child.stdin.write(prompt);
         child.stdin.end();
         // Collect events from the parser

package/dist/agent/providers/openai-compat.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OpenAI-compatible API provider — works with any service that speaks
+ * the OpenAI chat completions API: OpenAI, Groq, Together, Ollama, etc.
+ *
+ * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
+ * Converts OpenAI's delta format to the canonical StreamEvent union.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+export interface OpenAICompatProviderOptions {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+    /** Base URL for the API (default: https://api.openai.com). Include /v1 if needed. */
+    baseUrl?: string;
+}
+export declare class OpenAICompatProvider implements AgentProvider {
+    private apiKey;
+    private model;
+    private maxTokens;
+    private baseUrl;
+    constructor(options: OpenAICompatProviderOptions);
+    stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createOpenAICompatProvider(options: OpenAICompatProviderOptions): OpenAICompatProvider;
+//# sourceMappingURL=openai-compat.d.ts.map

package/dist/agent/providers/openai-compat.js

@@ -0,0 +1,204 @@
+/**
+ * OpenAI-compatible API provider — works with any service that speaks
+ * the OpenAI chat completions API: OpenAI, Groq, Together, Ollama, etc.
+ *
+ * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
+ * Converts OpenAI's delta format to the canonical StreamEvent union.
+ */
+export class OpenAICompatProvider {
+    apiKey;
+    model;
+    maxTokens;
+    baseUrl;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error('OpenAICompatProvider requires an API key');
+        }
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? 'gpt-4o';
+        this.maxTokens = options.maxTokens ?? 4096;
+        this.baseUrl = (options.baseUrl ?? 'https://api.openai.com').replace(/\/+$/, '');
+    }
+    async *stream(messages, tools, options) {
+        const model = options?.model ?? this.model;
+        const maxTokens = options?.maxTokens ?? this.maxTokens;
+        // Build OpenAI-format messages
+        const apiMessages = messages.map((m) => formatMessage(m));
+        // Build OpenAI-format tools
+        const apiTools = tools.length > 0
+            ? tools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                },
+            }))
+            : undefined;
+        const body = {
+            model,
+            messages: [
+                ...(options?.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+                ...apiMessages,
+            ],
+            max_tokens: maxTokens,
+            stream: true,
+        };
+        if (apiTools && apiTools.length > 0) {
+            body.tools = apiTools;
+        }
+        // Determine the completions endpoint
+        const url = this.baseUrl.includes('/v1/')
+            ? `${this.baseUrl}chat/completions`
+            : `${this.baseUrl}/v1/chat/completions`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            yield { type: 'text_delta', text: `OpenAI API error ${response.status}: ${errText.slice(0, 300)}` };
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        // Parse SSE stream
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let hasToolCalls = false;
+        // Track active tool calls (OpenAI sends incremental deltas by index)
+        const activeToolCalls = new Map();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (data === '[DONE]') {
+                        // Flush any pending tool calls
+                        for (const [, tc] of activeToolCalls) {
+                            let args = {};
+                            try {
+                                args = JSON.parse(tc.argsJson);
+                            }
+                            catch { /* malformed */ }
+                            yield { type: 'tool_use_end', id: tc.id, arguments: args };
+                        }
+                        yield { type: 'message_stop', finishReason: hasToolCalls ? 'tool_calls' : 'stop' };
+                        return;
+                    }
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Extract usage if present
+                    if (parsed.usage) {
+                        const usage = parsed.usage;
+                        yield {
+                            type: 'usage',
+                            promptTokens: usage.prompt_tokens ?? 0,
+                            completionTokens: usage.completion_tokens ?? 0,
+                        };
+                    }
+                    const choices = parsed.choices;
+                    if (!choices || choices.length === 0)
+                        continue;
+                    const choice = choices[0];
+                    const delta = choice.delta;
+                    if (!delta)
+                        continue;
+                    // Text content
+                    if (delta.content && typeof delta.content === 'string') {
+                        yield { type: 'text_delta', text: delta.content };
+                    }
+                    // Tool calls
+                    const toolCalls = delta.tool_calls;
+                    if (toolCalls) {
+                        for (const tc of toolCalls) {
+                            const index = tc.index ?? 0;
+                            const fn = tc.function;
+                            if (tc.id) {
+                                // New tool call
+                                hasToolCalls = true;
+                                const name = fn?.name ? String(fn.name) : 'unknown';
+                                activeToolCalls.set(index, { id: String(tc.id), name, argsJson: '' });
+                                yield { type: 'tool_use_start', id: String(tc.id), name };
+                            }
+                            // Accumulate function arguments
+                            if (fn?.arguments && typeof fn.arguments === 'string') {
+                                const existing = activeToolCalls.get(index);
+                                if (existing) {
+                                    existing.argsJson += fn.arguments;
+                                    yield { type: 'tool_use_delta', id: existing.id, partialJson: fn.arguments };
+                                }
+                            }
+                        }
+                    }
+                    // Finish reason
+                    if (choice.finish_reason === 'tool_calls') {
+                        hasToolCalls = true;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // If we got here without [DONE], flush
+        for (const [, tc] of activeToolCalls) {
+            let args = {};
+            try {
+                args = JSON.parse(tc.argsJson);
+            }
+            catch { /* malformed */ }
+            yield { type: 'tool_use_end', id: tc.id, arguments: args };
+        }
+        yield { type: 'message_stop', finishReason: hasToolCalls ? 'tool_calls' : 'stop' };
+    }
+}
+function formatMessage(m) {
+    if (m.role === 'tool') {
+        return {
+            role: 'tool',
+            tool_call_id: m.toolCallId,
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        };
+    }
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+        return {
+            role: 'assistant',
+            content: typeof m.content === 'string' && m.content ? m.content : null,
+            tool_calls: m.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+            })),
+        };
+    }
+    return {
+        role: m.role,
+        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+    };
+}
+export function createOpenAICompatProvider(options) {
+    return new OpenAICompatProvider(options);
+}
+//# sourceMappingURL=openai-compat.js.map

package/dist/agent/types.d.ts

@@ -70,6 +70,12 @@ export interface StreamOptions {
     model?: string;
     maxTokens?: number;
     signal?: AbortSignal;
+    /** Tool executor for providers that handle tool loops internally (e.g. CLI via MCP). */
+    executor?: ToolExecutor;
+    /** Event callback for tool events from internal tool loops. */
+    onToolEvent?: (event: ToolEvent) => void;
+    /** Per-request timeout in milliseconds (overrides provider default). */
+    timeout?: number;
 }
 export interface AgentProvider {
     stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;

package/dist/cli/flow-weaver.mjs

@@ -9886,7 +9886,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.22.7";
+    VERSION = "0.22.9";
   }
 });
 
@@ -94939,7 +94939,7 @@ var {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.22.7" : "0.0.0-dev";
+var version2 = true ? "0.22.9" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.22.7";
+export declare const VERSION = "0.22.9";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.22.7';
+export const VERSION = '0.22.9';
 //# sourceMappingURL=generated-version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.22.7",
+  "version": "0.22.9",
   "description": "Deterministic workflow compiler for AI agents. Compiles to standalone TypeScript, no runtime dependencies.",
   "private": false,
   "type": "module",