@synergenius/flow-weaver 0.33.2 → 0.44.0

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

@@ -1,205 +0,0 @@
-/**
- * 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 { joinSplitPrompt } from '../types.js';
-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: joinSplitPrompt(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/providers/platform.d.ts

@@ -1,23 +0,0 @@
-/**
- * Platform AI provider — routes AI calls through the Flow Weaver platform.
- * Uses the platform's AI credits, no local API key needed.
- * Connects to POST /ai-chat/stream and parses SSE events.
- */
-import { type AgentProvider, type AgentMessage, type ToolDefinition, type StreamEvent, type StreamOptions } from '../types.js';
-export interface PlatformProviderOptions {
-    /** JWT token or API key for platform auth */
-    token: string;
-    /** Platform base URL */
-    platformUrl: string;
-    /** Model override (optional — platform selects default) */
-    model?: string;
-}
-export declare class PlatformProvider implements AgentProvider {
-    private token;
-    private baseUrl;
-    private model;
-    constructor(options: PlatformProviderOptions);
-    stream(messages: AgentMessage[], _tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
-}
-export declare function createPlatformProvider(options: PlatformProviderOptions): PlatformProvider;
-//# sourceMappingURL=platform.d.ts.map

package/dist/agent/providers/platform.js

@@ -1,132 +0,0 @@
-/**
- * Platform AI provider — routes AI calls through the Flow Weaver platform.
- * Uses the platform's AI credits, no local API key needed.
- * Connects to POST /ai-chat/stream and parses SSE events.
- */
-import { joinSplitPrompt } from '../types.js';
-export class PlatformProvider {
-    token;
-    baseUrl;
-    model;
-    constructor(options) {
-        if (!options.token)
-            throw new Error('PlatformProvider requires a token');
-        if (!options.platformUrl)
-            throw new Error('PlatformProvider requires a platformUrl');
-        this.token = options.token;
-        this.baseUrl = options.platformUrl.replace(/\/+$/, '');
-        this.model = options.model;
-    }
-    async *stream(messages, _tools, options) {
-        // Format the last user message as the prompt
-        // The platform's agent loop handles tools internally
-        const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
-        const message = lastUserMsg
-            ? (typeof lastUserMsg.content === 'string' ? lastUserMsg.content : JSON.stringify(lastUserMsg.content))
-            : '';
-        if (!message) {
-            yield { type: 'message_stop', finishReason: 'stop' };
-            return;
-        }
-        const isApiKey = this.token.startsWith('fw_');
-        const headers = {
-            'Content-Type': 'application/json',
-            ...(isApiKey
-                ? { 'X-API-Key': this.token }
-                : { Authorization: `Bearer ${this.token}` }),
-        };
-        const body = { message };
-        if (options?.systemPrompt) {
-            // Platform doesn't accept system prompt directly via API — embed in message
-            const systemStr = joinSplitPrompt(options.systemPrompt);
-            body.message = `[System context: ${systemStr.slice(0, 2000)}]\n\n${message}`;
-        }
-        const response = await fetch(`${this.baseUrl}/ai-chat/stream`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-            signal: options?.signal,
-        });
-        if (!response.ok) {
-            const errText = await response.text().catch(() => '');
-            yield { type: 'text_delta', text: `Platform 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 from platform
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        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;
-                    let event;
-                    try {
-                        event = JSON.parse(line.slice(6));
-                    }
-                    catch {
-                        continue;
-                    }
-                    // Map platform SSE events to canonical StreamEvent
-                    switch (event.type) {
-                        case 'text_delta':
-                            yield { type: 'text_delta', text: String(event.content ?? '') };
-                            break;
-                        case 'thinking_delta':
-                            yield { type: 'thinking_delta', text: String(event.content ?? '') };
-                            break;
-                        case 'tool_call_start':
-                            yield {
-                                type: 'tool_use_start',
-                                id: String(event.toolCallId ?? ''),
-                                name: String(event.name ?? ''),
-                            };
-                            break;
-                        case 'tool_call_result':
-                            yield {
-                                type: 'tool_result',
-                                id: String(event.toolCallId ?? ''),
-                                result: String(event.result ?? ''),
-                                isError: !!event.isError,
-                            };
-                            break;
-                        case 'usage':
-                            yield {
-                                type: 'usage',
-                                promptTokens: event.promptTokens ?? 0,
-                                completionTokens: event.completionTokens ?? 0,
-                            };
-                            break;
-                        case 'done':
-                            yield { type: 'message_stop', finishReason: 'stop' };
-                            return;
-                        case 'error':
-                            yield { type: 'text_delta', text: `Error: ${event.message ?? 'Unknown error'}` };
-                            yield { type: 'message_stop', finishReason: 'error' };
-                            return;
-                    }
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        yield { type: 'message_stop', finishReason: 'stop' };
-    }
-}
-export function createPlatformProvider(options) {
-    return new PlatformProvider(options);
-}
-//# sourceMappingURL=platform.js.map

package/dist/agent/streaming.js

@@ -1,186 +0,0 @@
-/**
- * StreamJsonParser — parses Claude CLI stream-json NDJSON output into
- * typed StreamEvent values.
- *
- * Extracted from the duplicated parsing logic in platform's claude.ts
- * and cli-session.ts. Handles:
- * - stream_event wrapper unwrapping
- * - content_block lifecycle (text, tool_use, thinking)
- * - Tool argument accumulation (input_json_delta → tool_use_end)
- * - Tool result blocks from CLI's internal tool loop (user events)
- * - Usage tracking from message_start, message_delta, and result
- * - result event as text fallback and turn boundary
- *
- * The parser does NOT decide turn boundaries — consumers (one-shot vs
- * persistent session) handle that differently.
- */
-export class StreamJsonParser {
-    pushEvent;
-    hasAssistantText = false;
-    insideToolUse = false;
-    activeToolJsonChunks = new Map();
-    constructor(pushEvent) {
-        this.pushEvent = pushEvent;
-    }
-    /** Reset per-turn state. Call before starting a new turn in persistent sessions. */
-    reset() {
-        this.hasAssistantText = false;
-        this.insideToolUse = false;
-        this.activeToolJsonChunks.clear();
-    }
-    /** Whether any text_delta events have been emitted this turn. */
-    get hasText() {
-        return this.hasAssistantText;
-    }
-    /**
-     * Feed a single NDJSON line (without trailing newline).
-     * Parses and emits StreamEvent(s) via the callback.
-     */
-    feed(line) {
-        if (!line.trim())
-            return;
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            // Non-JSON line — only use as text if no other source is available
-            if (line.trim() && !this.hasAssistantText) {
-                this.pushEvent({ type: 'text_delta', text: line });
-            }
-            return;
-        }
-        // Unwrap stream_event wrapper (--include-partial-messages wraps API events)
-        if (event.type === 'stream_event' && event.event) {
-            event = event.event;
-        }
-        this.processEvent(event);
-    }
-    processEvent(event) {
-        const block = event.content_block;
-        const delta = event.delta;
-        // --- content_block_start ---
-        if (event.type === 'content_block_start' && block?.type === 'tool_use') {
-            this.insideToolUse = true;
-            const id = block.id || `cli-tool-${Date.now()}`;
-            const name = block.name || 'unknown';
-            this.pushEvent({ type: 'tool_use_start', id, name });
-            this.activeToolJsonChunks.set(id, { name, chunks: [] });
-            return;
-        }
-        if (event.type === 'content_block_start' && block?.type === 'text') {
-            this.insideToolUse = false;
-            return;
-        }
-        // --- content_block_delta ---
-        if (event.type === 'content_block_delta' && delta?.type === 'input_json_delta') {
-            const lastTool = [...this.activeToolJsonChunks.entries()].pop();
-            if (lastTool)
-                lastTool[1].chunks.push(delta.partial_json || '');
-            return;
-        }
-        if (event.type === 'content_block_delta' && delta?.type === 'thinking_delta' && delta?.thinking) {
-            this.pushEvent({ type: 'thinking_delta', text: delta.thinking });
-            return;
-        }
-        if (event.type === 'content_block_delta' && delta?.text && !this.insideToolUse) {
-            this.hasAssistantText = true;
-            this.pushEvent({ type: 'text_delta', text: delta.text });
-            return;
-        }
-        // --- content_block_stop ---
-        if (event.type === 'content_block_stop' && this.insideToolUse) {
-            const lastTool = [...this.activeToolJsonChunks.entries()].pop();
-            if (lastTool) {
-                const [id, { chunks }] = lastTool;
-                let args = {};
-                try {
-                    args = JSON.parse(chunks.join(''));
-                }
-                catch {
-                    /* malformed */
-                }
-                this.pushEvent({ type: 'tool_use_end', id, arguments: args });
-                this.activeToolJsonChunks.delete(id);
-            }
-            this.insideToolUse = false;
-            return;
-        }
-        // --- user event with tool_result blocks (CLI's internal tool loop) ---
-        if (event.type === 'user' && event.message?.content) {
-            const content = event.message.content;
-            for (const contentBlock of content) {
-                if (contentBlock.type === 'tool_result' && contentBlock.tool_use_id) {
-                    const text = Array.isArray(contentBlock.content)
-                        ? contentBlock.content
-                            .map((c) => c.text || '')
-                            .join('')
-                        : String(contentBlock.content || '');
-                    this.pushEvent({
-                        type: 'tool_result',
-                        id: contentBlock.tool_use_id,
-                        result: text,
-                        isError: !!contentBlock.is_error,
-                    });
-                }
-            }
-            return;
-        }
-        // --- message_start (usage) ---
-        if (event.type === 'message_start' && event.message?.usage) {
-            const usage = event.message.usage;
-            this.pushEvent({
-                type: 'usage',
-                promptTokens: usage.input_tokens ?? 0,
-                completionTokens: usage.output_tokens ?? 0,
-            });
-            return;
-        }
-        // --- message_delta (usage) ---
-        if (event.type === 'message_delta' && event.usage) {
-            const usage = event.usage;
-            this.pushEvent({
-                type: 'usage',
-                promptTokens: 0,
-                completionTokens: usage.output_tokens ?? 0,
-            });
-            return;
-        }
-        // --- message_stop ---
-        if (event.type === 'message_stop') {
-            this.pushEvent({ type: 'message_stop', finishReason: 'stop' });
-            return;
-        }
-        // --- result event (CLI turn boundary) ---
-        if (event.type === 'result') {
-            if (event.is_error) {
-                this.pushEvent({ type: 'message_stop', finishReason: 'error' });
-                return;
-            }
-            // result text is a fallback — only use if content_block_delta never fired
-            if (event.result && !this.hasAssistantText) {
-                this.pushEvent({ type: 'text_delta', text: event.result });
-            }
-            if (event.usage) {
-                const usage = event.usage;
-                this.pushEvent({
-                    type: 'usage',
-                    promptTokens: usage.input_tokens ?? 0,
-                    completionTokens: usage.output_tokens ?? 0,
-                    cacheReadTokens: usage.cache_read_input_tokens ?? undefined,
-                    cacheCreationTokens: usage.cache_creation_input_tokens ?? undefined,
-                    costUsd: typeof event.total_cost_usd === 'number' ? event.total_cost_usd : undefined,
-                });
-            }
-            this.pushEvent({ type: 'message_stop', finishReason: 'stop' });
-            return;
-        }
-        // --- assistant event (auth failure detection) ---
-        if (event.type === 'assistant') {
-            if (event.error === 'authentication_failed') {
-                this.pushEvent({ type: 'message_stop', finishReason: 'error' });
-            }
-        }
-    }
-}
-//# sourceMappingURL=streaming.js.map

package/dist/agent/types.js

@@ -1,20 +0,0 @@
-/**
- * Shared types for the agent loop, providers, and MCP bridge.
- *
- * All types are pure — no runtime imports, no side effects.
- */
-/** Convert a SplitPrompt to a single string (for providers that don't support blocks). */
-export function joinSplitPrompt(prompt) {
-    if (!prompt.suffix)
-        return prompt.prefix;
-    return prompt.prefix + '\n\n' + prompt.suffix;
-}
-/**
- * Strip MCP server prefix from a tool name.
- * The CLI registers MCP tools as mcp__<server>__<tool> but internal code
- * uses unprefixed names. Call this before any tool name comparison.
- */
-export function stripMcpToolPrefix(name) {
-    return name.replace(/^mcp__[a-zA-Z0-9_-]+__/, '');
-}
-//# sourceMappingURL=types.js.map

package/dist/annotation-generator.d.ts

@@ -1,50 +0,0 @@
-import type { TNodeTypeAST, TNodeInstanceAST, TPortDefinition, TWorkflowAST } from "./ast/index.js";
-export interface GenerateAnnotationsOptions {
-    includeComments?: boolean;
-    includeMetadata?: boolean;
-    indentSize?: number;
-    skipParamReturns?: boolean;
-}
-export declare class AnnotationGenerator {
-    generate(workflow: TWorkflowAST, options?: GenerateAnnotationsOptions): string;
-    private generateNodeTypeAnnotation;
-    private generateJSDocPortTag;
-    private generateTPortDefinition;
-    private generateFunctionSignature;
-    private generateWorkflowAnnotation;
-    private generateWorkflowFunctionSignature;
-    private assignPortOrders;
-    private mapDataTypeToTS;
-}
-/**
- * Generate JSDoc port tag (e.g., @input name - Description)
- * Exported for reuse in generate-in-place.ts to maintain DRY principle
- *
- * New format (types derived from signature):
- * - @input name - Description
- * - @output name - Description
- * - @step name - Description (for explicit STEP/control-flow ports)
- *
- * Reserved STEP ports (execute, onSuccess, onFailure) use @input/@output.
- * Custom STEP ports use @step.
- */
-export declare function generateJSDocPortTag(rawName: string, port: TPortDefinition, direction: 'input' | 'output', _implicitOrder?: number): string;
-/**
- * Simply return ports as-is to preserve exact order from the AST
- * Don't compute or add any new metadata - only preserve what's already there
- * This ensures perfect round-trip fidelity
- * Exported for reuse in generate-in-place.ts to maintain DRY principle
- */
-export declare function assignPortOrders(ports: [string, TPortDefinition][], _direction: 'input' | 'output'): [string, TPortDefinition][];
-/**
- * Generate @node tag for a single instance
- * Exported for reuse in generate-in-place.ts to maintain DRY principle
- */
-export declare function generateNodeInstanceTag(instance: TNodeInstanceAST): string;
-/**
- * Generate a TypeScript function signature from a node type definition.
- * Handles three modes: stub (declare function), expression (pure function), normal (execute/onSuccess/onFailure).
- */
-export declare function generateFunctionSignature(nodeType: TNodeTypeAST): string[];
-export declare const annotationGenerator: AnnotationGenerator;
-//# sourceMappingURL=annotation-generator.d.ts.map