@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/templates/workflows/ai-agent.js

@@ -1,326 +0,0 @@
-import { getProviderCode } from '../providers/index.js';
-import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER_WITH_TOOLS } from '../shared/llm-types.js';
-/** Shared configSchema for AI templates */
-export const aiConfigSchema = {
-    provider: {
-        type: 'select',
-        label: 'LLM Provider',
-        description: 'Choose your LLM provider',
-        default: 'mock',
-        options: [
-            { value: 'openai', label: 'OpenAI' },
-            { value: 'anthropic', label: 'Anthropic' },
-            { value: 'ollama', label: 'Ollama (Local)' },
-            { value: 'mock', label: 'Mock (Testing)' },
-        ],
-    },
-    model: {
-        type: 'string',
-        label: 'Model',
-        description: 'Model identifier',
-        default: 'gpt-4o',
-        placeholder: 'e.g., gpt-4o, claude-3-5-sonnet-20241022, llama3.2',
-        dependsOn: {
-            field: 'provider',
-            values: ['openai', 'anthropic', 'ollama'],
-        },
-    },
-};
-export const aiAgentTemplate = {
-    id: 'ai-agent',
-    name: 'AI Agent (Tool Calling)',
-    description: 'Stateful LLM agent with explicit reasoning loop and tool execution',
-    category: 'ai',
-    configSchema: aiConfigSchema,
-    generate: ({ workflowName, config }) => {
-        const provider = config?.provider || 'mock';
-        const model = config?.model || '';
-        // Get provider-specific code or use mock
-        const providerCode = provider === 'mock'
-            ? `
-/* ============================================================
- * MOCK PROVIDER (REPLACE IN REAL USE)
- * ============================================================
- */
-
-${LLM_MOCK_PROVIDER_WITH_TOOLS}
-`
-            : getProviderCode(provider, model);
-        return `
-/* ============================================================
- * CORE TYPES
- * ============================================================
- */
-
-${LLM_CORE_TYPES}
-
-type TerminationReason =
-  | 'completed'
-  | 'max_iterations'
-  | 'tool_error'
-  | 'llm_error'
-  | 'aborted';
-
-/* ============================================================
- * AGENT STATE
- * ============================================================
- */
-
-interface AgentState {
-  messages: LLMMessage[];
-  iteration: number;
-  toolsUsed: string[];
-  terminated: boolean;
-  terminationReason?: TerminationReason;
-  finalResponse?: string;
-}
-
-${providerCode}
-
-const SYSTEM_PROMPT = \`You are a helpful AI assistant with access to tools.
-Use tools when necessary. Respond directly when the task is complete.\`;
-
-const MAX_ITERATIONS = 10;
-
-/* ============================================================
- * TOOLS
- * ============================================================
- */
-
-const AVAILABLE_TOOLS: LLMTool[] = [
-  {
-    name: 'search',
-    description: 'Search for information',
-    parameters: {
-      type: 'object',
-      properties: {
-        query: { type: 'string' },
-      },
-      required: ['query'],
-    },
-  },
-];
-
-type ToolResult =
-  | { ok: true; value: string }
-  | { ok: false; error: string };
-
-type ToolFn = (args: Record<string, unknown>) => Promise<ToolResult>;
-
-const TOOL_IMPLEMENTATIONS: Record<string, ToolFn> = {
-  async search(args) {
-    if (typeof args.query !== 'string') {
-      return { ok: false, error: 'Invalid query' };
-    }
-    return { ok: true, value: '[Search results for: ' + args.query + ']' };
-  },
-};
-
-/* ============================================================
- * NODES
- * ============================================================
- */
-
-/**
- * Agent loop that orchestrates LLM calls and tool execution
- * Uses scoped ports to handle iteration internally
- *
- * @flowWeaver nodeType
- * @label Agent Loop
- * @input userMessage [order:1] - User's input message
- * @input [maxIterations] [order:2] - Maximum loop iterations (default: 10)
- * @input success scope:iteration [order:0] - From LLM onSuccess
- * @input failure scope:iteration [order:1] - From LLM onFailure
- * @input llmResponse scope:iteration [order:2] - LLM response
- * @input toolMessages scope:iteration [order:3] - Tool results
- * @input execute [order:0] - Execute
- * @output start scope:iteration [order:0] - Triggers iteration
- * @output state scope:iteration [order:1] - Current agent state
- * @output response [order:2] - Final response when done
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function agentLoop(
-  execute: boolean,
-  userMessage: string,
-  maxIterations: number = MAX_ITERATIONS,
-  iteration: (start: boolean, state: AgentState) => Promise<{
-    success: boolean;
-    failure: boolean;
-    llmResponse: LLMResponse | null;
-    toolMessages: LLMMessage[];
-  }>
-): Promise<{ onSuccess: boolean; onFailure: boolean; response: string }> {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, response: '' };
-  }
-
-  let state: AgentState = {
-    messages: [{ role: 'user', content: userMessage }],
-    iteration: 0,
-    toolsUsed: [],
-    terminated: false,
-  };
-
-  while (state.iteration < maxIterations) {
-    const result = await iteration(true, state);
-
-    state.iteration++;
-
-    // Handle LLM failure
-    if (result.failure) {
-      return { onSuccess: false, onFailure: true, response: 'LLM error occurred' };
-    }
-
-    // Add assistant message if present
-    if (result.llmResponse?.content) {
-      state.messages.push({ role: 'assistant', content: result.llmResponse.content });
-    }
-
-    // Add tool messages
-    if (result.toolMessages && result.toolMessages.length > 0) {
-      state.messages.push(...result.toolMessages);
-    }
-
-    // Check termination: no tool calls means we're done
-    if (result.llmResponse && result.llmResponse.toolCalls.length === 0 && result.llmResponse.content) {
-      return { onSuccess: true, onFailure: false, response: result.llmResponse.content };
-    }
-  }
-
-  return { onSuccess: true, onFailure: false, response: 'Max iterations reached' };
-}
-
-/**
- * Calls the LLM with current state
- *
- * @flowWeaver nodeType
- * @label Call LLM
- * @input state [order:1] - Current agent state
- * @input execute [order:0] - Execute
- * @output response [order:2] - LLM response
- * @output toolCalls [order:3] - Tool calls from LLM
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function callLLM(
-  execute: boolean,
-  state: AgentState
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  response: LLMResponse | null;
-  toolCalls: LLMToolCall[];
-}> {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, response: null, toolCalls: [] };
-  }
-
-  try {
-    const response = await llmProvider.chat(state.messages, {
-      tools: AVAILABLE_TOOLS,
-      systemPrompt: SYSTEM_PROMPT,
-    });
-
-    return { onSuccess: true, onFailure: false, response, toolCalls: response.toolCalls };
-  } catch {
-    return { onSuccess: false, onFailure: true, response: null, toolCalls: [] };
-  }
-}
-
-/**
- * Executes tool calls
- *
- * @flowWeaver nodeType
- * @label Execute Tools
- * @input calls [order:1] - Tool calls to execute
- * @input execute [order:0] - Execute
- * @output messages [order:2] - Tool response messages
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function executeTools(
-  execute: boolean,
-  calls: LLMToolCall[]
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  messages: LLMMessage[];
-}> {
-  if (!execute || !calls || calls.length === 0) {
-    return { onSuccess: true, onFailure: false, messages: [] };
-  }
-
-  const messages: LLMMessage[] = [];
-
-  for (const call of calls) {
-    const impl = TOOL_IMPLEMENTATIONS[call.name];
-    if (!impl) {
-      messages.push({
-        role: 'tool',
-        content: 'Unknown tool: ' + call.name,
-        toolCallId: call.id,
-      });
-      continue;
-    }
-
-    const result = await impl(call.arguments);
-
-    messages.push({
-      role: 'tool',
-      content: result.ok ? result.value : 'Error: ' + result.error,
-      toolCallId: call.id,
-    });
-  }
-
-  return { onSuccess: true, onFailure: false, messages };
-}
-
-/* ============================================================
- * WORKFLOW
- * ============================================================
- */
-
-/**
- * AI Agent that uses tools to accomplish tasks
- *
- * @flowWeaver workflow
- * @node loop agentLoop [position: -180 0] [color: "purple"] [icon: "smartToy"]
- * @node llm callLLM loop.iteration [color: "blue"] [icon: "psychology"]
- * @node tools executeTools loop.iteration [color: "orange"] [icon: "build"] [suppress: "AGENT_UNGUARDED_TOOL_EXECUTOR"]
- * @position Start -450 0
- * @position Exit 360 0
- * @connect Start.execute -> loop.execute
- * @connect Start.userMessage -> loop.userMessage
- * @connect loop.start:iteration -> llm.execute
- * @connect loop.state:iteration -> llm.state
- * @connect llm.toolCalls -> tools.calls
- * @connect llm.onSuccess -> tools.execute
- * @connect llm.response -> loop.llmResponse:iteration
- * @connect llm.onSuccess -> loop.success:iteration
- * @connect llm.onFailure -> loop.failure:iteration
- * @connect tools.messages -> loop.toolMessages:iteration
- * @connect tools.onFailure -> loop.failure:iteration
- * @connect loop.response -> Exit.response
- * @connect loop.onSuccess -> Exit.onSuccess
- * @connect loop.onFailure -> Exit.onFailure
- * @param execute [order:0] - Execute
- * @param userMessage [order:1] - User's message to the agent
- * @returns onSuccess [order:0] - Agent completed successfully
- * @returns onFailure [order:1] - Agent encountered an error
- * @returns response [order:2] - Agent's final response
- */
-export async function ${workflowName}(
-  execute: boolean,
-  params: { userMessage: string }
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  response: string;
-}> {
-  throw new Error('Compile with: fw compile <file>');
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=ai-agent.js.map

package/dist/cli/templates/workflows/ai-chat.js

@@ -1,167 +0,0 @@
-import { getProviderCode } from '../providers/index.js';
-import { aiConfigSchema } from './ai-agent.js';
-import { LLM_SIMPLE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
-export const aiChatTemplate = {
-    id: 'ai-chat',
-    name: 'Stateful Chat',
-    description: 'Conversational AI with memory management',
-    category: 'ai',
-    configSchema: aiConfigSchema,
-    generate: (opts) => {
-        const { workflowName, config } = opts;
-        const provider = config?.provider || 'mock';
-        const model = config?.model || '';
-        // Get provider-specific code or use mock
-        const providerCode = provider === 'mock'
-            ? `
-// Mock provider for testing - replace with real provider
-${LLM_MOCK_PROVIDER}
-`
-            : getProviderCode(provider, model);
-        return `
-// ============================================================
-// LLM TYPES - Provider-agnostic interface
-// ============================================================
-
-${LLM_SIMPLE_TYPES}
-
-${providerCode}
-
-// Conversation memory store
-const conversations: Map<string, LLMMessage[]> = new Map();
-
-const DEFAULT_SYSTEM_PROMPT = \`You are a helpful AI assistant.
-Be concise but friendly. Remember context from earlier in the conversation.\`;
-
-/**
- * Manages conversation memory
- *
- * @flowWeaver nodeType
- * @label Memory
- * @input conversationId [order:1] - Conversation identifier
- * @input [newMessage] [order:2] - Message to add
- * @input [maxHistory=50] [order:3] - Max messages to retain
- * @input execute [order:0] - Execute
- * @output history [order:2] - Conversation history
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function memory(
-  execute: boolean,
-  conversationId: string,
-  newMessage?: LLMMessage,
-  maxHistory?: number
-): {
-  onSuccess: boolean;
-  onFailure: boolean;
-  history: LLMMessage[];
-} {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, history: [] };
-  }
-
-  if (!conversations.has(conversationId)) {
-    conversations.set(conversationId, []);
-  }
-
-  const history = conversations.get(conversationId)!;
-
-  if (newMessage) {
-    history.push(newMessage);
-    const max = maxHistory ?? 50;
-    while (history.length > max) {
-      history.shift();
-    }
-  }
-
-  return { onSuccess: true, onFailure: false, history: [...history] };
-}
-
-/**
- * Generates chat response
- *
- * @flowWeaver nodeType
- * @label Chat
- * @input history [order:1] - Conversation history
- * @input [systemPrompt] [order:2] - System prompt
- * @input execute [order:0] - Execute
- * @output response [order:2] - Assistant response
- * @output responseMessage [order:3] - Response as LLMMessage
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function chat(
-  execute: boolean,
-  history: LLMMessage[],
-  systemPrompt?: string
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  response: string;
-  responseMessage: LLMMessage;
-}> {
-  if (!execute) {
-    return {
-      onSuccess: false,
-      onFailure: false,
-      response: '',
-      responseMessage: { role: 'assistant', content: '' },
-    };
-  }
-
-  const response = await llmProvider.chat(history, {
-    systemPrompt: systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
-  });
-
-  const content = response.content ?? '';
-
-  return {
-    onSuccess: true,
-    onFailure: false,
-    response: content,
-    responseMessage: { role: 'assistant', content },
-  };
-}
-
-/**
- * Stateful chat with conversation memory
- *
- * @flowWeaver workflow
- * @node mem memory [position: -150 0] [color: "teal"] [icon: "database"]
- * @node respond chat [position: 50 0] [color: "purple"] [icon: "campaign"] [suppress: "AGENT_LLM_NO_FALLBACK"]
- * @node saveMem memory [position: 250 0] [color: "teal"] [icon: "database"] [suppress: "UNUSED_OUTPUT_PORT"]
- * @position Start -350 0
- * @position Exit 450 0
- * @connect Start.execute -> mem.execute
- * @connect Start.conversationId -> mem.conversationId
- * @connect Start.userMessage -> mem.newMessage
- * @connect mem.history -> respond.history
- * @connect mem.onSuccess -> respond.execute
- * @connect Start.conversationId -> saveMem.conversationId
- * @connect respond.responseMessage -> saveMem.newMessage
- * @connect respond.onSuccess -> saveMem.execute
- * @connect respond.onFailure -> Exit.onFailure
- * @connect respond.response -> Exit.response
- * @connect saveMem.onSuccess -> Exit.onSuccess
- * @param execute [order:0] - Execute
- * @param conversationId [order:1] - Unique conversation ID
- * @param userMessage [order:2] - User's message
- * @param systemPrompt [order:3] - System prompt (optional)
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns response [order:2] - Assistant's response
- */
-export async function ${workflowName}(
-  execute: boolean,
-  params: { conversationId: string; userMessage: LLMMessage; systemPrompt?: string }
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  response: string;
-}> {
-  throw new Error('Compile with: fw compile <file>');
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=ai-chat.js.map

package/dist/cli/templates/workflows/ai-rag.js

@@ -1,184 +0,0 @@
-import { getProviderCode } from '../providers/index.js';
-import { aiConfigSchema } from './ai-agent.js';
-import { LLM_SIMPLE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
-export const aiRagTemplate = {
-    id: 'ai-rag',
-    name: 'RAG Pipeline',
-    description: 'Retrieval-Augmented Generation for knowledge-based Q&A',
-    category: 'ai',
-    configSchema: aiConfigSchema,
-    generate: (opts) => {
-        const { workflowName, config } = opts;
-        const provider = config?.provider || 'mock';
-        const model = config?.model || '';
-        // Get provider-specific code or use mock
-        const providerCode = provider === 'mock'
-            ? `
-// Mock provider for testing - replace with real provider
-${LLM_MOCK_PROVIDER}
-`
-            : getProviderCode(provider, model);
-        return `
-// ============================================================
-// LLM TYPES - Provider-agnostic interface
-// ============================================================
-
-${LLM_SIMPLE_TYPES}
-
-${providerCode}
-
-// Document store (replace with vector DB like Pinecone, Weaviate, etc.)
-interface Document {
-  id: string;
-  content: string;
-  metadata?: Record<string, unknown>;
-}
-
-const documentStore: Document[] = [
-  // TODO: Add your documents or connect to vector database
-  { id: '1', content: 'Flow Weaver is a visual programming tool.' },
-  { id: '2', content: 'It uses typed ports for data flow.' },
-];
-
-/**
- * Retrieves relevant documents for a query
- *
- * @flowWeaver nodeType
- * @label Retrieve
- * @input query [order:1] - Search query
- * @input [topK] [order:2] - Number of results (default 3)
- * @input execute [order:0] - Execute
- * @output documents [order:2] [hidden] - Retrieved documents
- * @output context [order:3] - Combined document text
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function retrieve(
-  execute: boolean,
-  query: string,
-  topK?: number
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  documents: Document[];
-  context: string;
-}> {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, documents: [], context: '' };
-  }
-
-  const k = topK ?? 3;
-
-  // TODO: Replace with actual vector similarity search
-  // For now, simple keyword matching
-  const queryLower = query.toLowerCase();
-  const scored = documentStore
-    .map((doc) => ({
-      doc,
-      score: doc.content.toLowerCase().includes(queryLower) ? 1 : 0,
-    }))
-    .filter((s) => s.score > 0)
-    .slice(0, k)
-    .map((s) => s.doc);
-
-  const context = scored.map((d) => d.content).join('\\n\\n');
-
-  return {
-    onSuccess: true,
-    onFailure: false,
-    documents: scored,
-    context,
-  };
-}
-
-/**
- * Generates answer using retrieved context
- *
- * @flowWeaver nodeType
- * @label Generate
- * @input question [order:1] - User question
- * @input context [order:2] - Retrieved context
- * @input execute [order:0] - Execute
- * @output answer [order:2] - Generated answer
- * @output sourcesUsed [order:3] - Number of sources used
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function generate(
-  execute: boolean,
-  question: string,
-  context: string
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  answer: string;
-  sourcesUsed: number;
-}> {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, answer: '', sourcesUsed: 0 };
-  }
-
-  const prompt = \`Answer the question based on the following context.
-If the context doesn't contain relevant information, say so.
-
-Context:
-\${context}
-
-Question: \${question}
-
-Answer:\`;
-
-  const response = await llmProvider.chat([{ role: 'user', content: prompt }]);
-  const sourcesUsed = context
-    .split('\\n\\n')
-    .filter((s) => s.trim()).length;
-
-  return {
-    onSuccess: true,
-    onFailure: false,
-    answer: response.content ?? '',
-    sourcesUsed,
-  };
-}
-
-/**
- * RAG Pipeline for knowledge-based Q&A
- *
- * @flowWeaver workflow
- * @node retriever retrieve [position: -50 0] [color: "teal"] [icon: "search"] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"]
- * @node generator generate [position: 200 0] [color: "purple"] [icon: "autoAwesome"]
- * @position Start -300 0
- * @position Exit 400 0
- * @connect Start.execute -> retriever.execute
- * @connect Start.question -> retriever.query
- * @connect Start.topK -> retriever.topK
- * @connect Start.question -> generator.question
- * @connect retriever.context -> generator.context
- * @connect retriever.onSuccess -> generator.execute
- * @connect generator.answer -> Exit.answer
- * @connect generator.sourcesUsed -> Exit.sourcesUsed
- * @connect generator.onSuccess -> Exit.onSuccess
- * @connect generator.onFailure -> Exit.onFailure
- * @param execute [order:0] - Execute
- * @param question [order:1] - User's question
- * @param topK [order:2] - Number of documents to retrieve
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns answer [order:2] - Generated answer
- * @returns sourcesUsed [order:3] - Number of sources used
- */
-export async function ${workflowName}(
-  execute: boolean,
-  params: { question: string; topK?: number }
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  answer: string;
-  sourcesUsed: number;
-}> {
-  throw new Error('Compile with: fw compile <file>');
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=ai-rag.js.map