@bluefly/openstandardagents 0.4.0 → 0.4.1

package/dist/services/export/langchain/langchain-exporter.js

@@ -0,0 +1,953 @@
+/**
+ * LangChain Exporter Service
+ *
+ * Exports OSSA manifests to production-ready LangChain agents with:
+ * - Python agent code with @tool decorators
+ * - FastAPI REST API server
+ * - OpenAPI 3.1 specification
+ * - Docker containerization
+ * - Memory configuration
+ *
+ * SOLID: Single Responsibility - LangChain export orchestration
+ * DRY: Reuses generators for each component
+ * API-First: Generates OpenAPI spec from OSSA manifest
+ */
+import { ToolsGenerator } from './tools-generator.js';
+import { MemoryGenerator } from './memory-generator.js';
+import { ApiGenerator } from './api-generator.js';
+import { OpenApiGenerator } from './openapi-generator.js';
+import { StreamingGenerator } from './streaming-generator.js';
+import { CallbacksGenerator } from './callbacks-generator.js';
+import { ErrorHandlingGenerator } from './error-handling-generator.js';
+import { TestGenerator } from '../testing/index.js';
+import { LangGraphGenerator } from './langgraph-generator.js';
+import { LangServeGenerator } from './langserve-generator.js';
+import { PlanExecuteGenerator } from './plan-execute-generator.js';
+/**
+ * LangChain Exporter
+ */
+export class LangChainExporter {
+    toolsGenerator;
+    memoryGenerator;
+    apiGenerator;
+    openApiGenerator;
+    streamingGenerator;
+    callbacksGenerator;
+    errorHandlingGenerator;
+    langGraphGenerator;
+    langserveGenerator;
+    planExecuteGenerator;
+    testGenerator;
+    constructor() {
+        this.toolsGenerator = new ToolsGenerator();
+        this.memoryGenerator = new MemoryGenerator();
+        this.apiGenerator = new ApiGenerator();
+        this.openApiGenerator = new OpenApiGenerator();
+        this.streamingGenerator = new StreamingGenerator();
+        this.callbacksGenerator = new CallbacksGenerator();
+        this.errorHandlingGenerator = new ErrorHandlingGenerator();
+        this.langGraphGenerator = new LangGraphGenerator();
+        this.langserveGenerator = new LangServeGenerator();
+        this.planExecuteGenerator = new PlanExecuteGenerator();
+        this.testGenerator = new TestGenerator();
+    }
+    /**
+     * Export OSSA manifest to LangChain
+     */
+    async export(manifest, options = {}) {
+        const startTime = Date.now();
+        try {
+            const files = [];
+            const pythonVersion = options.pythonVersion || '3.11';
+            const includeApi = options.includeApi !== false;
+            const includeOpenApi = options.includeOpenApi !== false;
+            const includeDocker = options.includeDocker !== false;
+            const memoryBackend = options.memoryBackend || 'buffer';
+            // Validate manifest
+            this.validateManifest(manifest);
+            // Determine agent architecture
+            const architecture = options.agentArchitecture || 'react';
+            const isMultiAgentWorkflow = this.langGraphGenerator.shouldUseLangGraph(manifest);
+            // Generate agent code based on architecture
+            if (architecture === 'plan-execute') {
+                // Generate Plan-and-Execute agents
+                const planExecuteConfig = options.planExecute || {};
+                const plannerCode = this.planExecuteGenerator.generatePlanner(manifest, planExecuteConfig);
+                files.push({
+                    path: 'planner_agent.py',
+                    content: plannerCode,
+                    type: 'code',
+                    language: 'python',
+                });
+                const executorCode = this.planExecuteGenerator.generateExecutor(manifest, planExecuteConfig);
+                files.push({
+                    path: 'executor_agent.py',
+                    content: executorCode,
+                    type: 'code',
+                    language: 'python',
+                });
+                const planExecuteCode = this.planExecuteGenerator.generatePlanExecute(manifest, planExecuteConfig);
+                files.push({
+                    path: 'plan_execute.py',
+                    content: planExecuteCode,
+                    type: 'code',
+                    language: 'python',
+                });
+                // Also generate main agent.py that imports plan_execute
+                const mainAgentCode = this.generatePlanExecuteMainAgent(manifest);
+                files.push({
+                    path: 'agent.py',
+                    content: mainAgentCode,
+                    type: 'code',
+                    language: 'python',
+                });
+            }
+            else {
+                // Generate ReAct agent (default)
+                const agentCode = this.generateAgentCode(manifest, options);
+                files.push({
+                    path: 'agent.py',
+                    content: agentCode,
+                    type: 'code',
+                    language: 'python',
+                });
+            }
+            // Generate LangGraph workflow if multi-agent
+            if (isMultiAgentWorkflow) {
+                const langGraphCode = this.langGraphGenerator.generate(manifest);
+                files.push({
+                    path: 'langgraph.py',
+                    content: langGraphCode,
+                    type: 'code',
+                    language: 'python',
+                });
+            }
+            // Generate tools
+            const toolsCode = this.toolsGenerator.generate(manifest);
+            files.push({
+                path: 'tools.py',
+                content: toolsCode,
+                type: 'code',
+                language: 'python',
+            });
+            // Generate memory configuration
+            const memoryCode = this.memoryGenerator.generate(manifest, memoryBackend);
+            files.push({
+                path: 'memory.py',
+                content: memoryCode,
+                type: 'code',
+                language: 'python',
+            });
+            // Generate streaming support
+            const streamingCode = this.streamingGenerator.generate(manifest, options.streaming || {});
+            files.push({
+                path: 'streaming.py',
+                content: streamingCode,
+                type: 'code',
+                language: 'python',
+            });
+            // Generate callbacks and observability
+            const callbacksCode = this.callbacksGenerator.generate(manifest, options.callbacks || {});
+            files.push({
+                path: 'callbacks.py',
+                content: callbacksCode,
+                type: 'code',
+                language: 'python',
+            });
+            // Generate error handling
+            const errorHandlingCode = this.errorHandlingGenerator.generate(manifest, options.errorHandling || {});
+            files.push({
+                path: 'error_handling.py',
+                content: errorHandlingCode,
+                type: 'code',
+                language: 'python',
+            });
+            // Generate FastAPI server
+            if (includeApi) {
+                const apiCode = this.apiGenerator.generate(manifest, options.apiPort);
+                files.push({
+                    path: 'server.py',
+                    content: apiCode,
+                    type: 'code',
+                    language: 'python',
+                });
+            }
+            // Generate OpenAPI spec
+            if (includeOpenApi) {
+                const openApiSpec = this.openApiGenerator.generate(manifest);
+                files.push({
+                    path: 'openapi.yaml',
+                    content: openApiSpec,
+                    type: 'config',
+                    language: 'yaml',
+                });
+            }
+            // Generate LangServe deployment (if requested)
+            if (options.includeLangServe) {
+                const langserveConfig = options.langserve || {};
+                // Generate LangServe app
+                const langserveApp = this.langserveGenerator.generateApp(manifest, langserveConfig);
+                files.push({
+                    path: 'langserve_app.py',
+                    content: langserveApp,
+                    type: 'code',
+                    language: 'python',
+                });
+                // Generate deployment configs
+                if (langserveConfig.includeDeployment !== false) {
+                    const platforms = langserveConfig.deploymentPlatforms || ['docker', 'kubernetes', 'railway', 'render', 'fly'];
+                    // Docker configs
+                    if (platforms.includes('docker')) {
+                        const langserveDockerfile = this.langserveGenerator.generateDockerfile(pythonVersion);
+                        files.push({
+                            path: 'Dockerfile.langserve',
+                            content: langserveDockerfile,
+                            type: 'config',
+                        });
+                        const langserveCompose = this.langserveGenerator.generateDockerCompose(manifest, langserveConfig);
+                        files.push({
+                            path: 'docker-compose.langserve.yaml',
+                            content: langserveCompose,
+                            type: 'config',
+                            language: 'yaml',
+                        });
+                    }
+                    // Kubernetes manifests
+                    if (platforms.includes('kubernetes')) {
+                        const k8sManifests = this.langserveGenerator.generateKubernetesManifests(manifest, langserveConfig);
+                        files.push({
+                            path: 'k8s/deployment.yaml',
+                            content: k8sManifests.deployment,
+                            type: 'config',
+                            language: 'yaml',
+                        });
+                        files.push({
+                            path: 'k8s/service.yaml',
+                            content: k8sManifests.service,
+                            type: 'config',
+                            language: 'yaml',
+                        });
+                        files.push({
+                            path: 'k8s/ingress.yaml',
+                            content: k8sManifests.ingress,
+                            type: 'config',
+                            language: 'yaml',
+                        });
+                    }
+                    // Railway config
+                    if (platforms.includes('railway')) {
+                        const railwayConfig = this.langserveGenerator.generateRailwayConfig(manifest, langserveConfig);
+                        files.push({
+                            path: 'railway.json',
+                            content: railwayConfig,
+                            type: 'config',
+                            language: 'json',
+                        });
+                    }
+                    // Render config
+                    if (platforms.includes('render')) {
+                        const renderConfig = this.langserveGenerator.generateRenderConfig(manifest, langserveConfig);
+                        files.push({
+                            path: 'render.yaml',
+                            content: renderConfig,
+                            type: 'config',
+                            language: 'yaml',
+                        });
+                    }
+                    // Fly.io config
+                    if (platforms.includes('fly')) {
+                        const flyConfig = this.langserveGenerator.generateFlyConfig(manifest, langserveConfig);
+                        files.push({
+                            path: 'fly.toml',
+                            content: flyConfig,
+                            type: 'config',
+                        });
+                    }
+                    // Deployment README
+                    const deploymentReadme = this.langserveGenerator.generateDeploymentReadme(manifest, langserveConfig);
+                    files.push({
+                        path: 'DEPLOYMENT.md',
+                        content: deploymentReadme,
+                        type: 'documentation',
+                        language: 'markdown',
+                    });
+                }
+            }
+            // Generate requirements.txt
+            const requirements = this.generateRequirements(manifest, options);
+            files.push({
+                path: 'requirements.txt',
+                content: requirements,
+                type: 'config',
+            });
+            // Generate Dockerfile
+            if (includeDocker) {
+                const dockerfile = this.generateDockerfile(pythonVersion);
+                files.push({
+                    path: 'Dockerfile',
+                    content: dockerfile,
+                    type: 'config',
+                });
+                const dockerCompose = this.generateDockerCompose(manifest, options);
+                files.push({
+                    path: 'docker-compose.yaml',
+                    content: dockerCompose,
+                    type: 'config',
+                    language: 'yaml',
+                });
+            }
+            // Generate .env.example
+            const envExample = this.generateEnvExample(manifest);
+            files.push({
+                path: '.env.example',
+                content: envExample,
+                type: 'config',
+            });
+            // Generate README
+            const readme = this.generateReadme(manifest, options);
+            files.push({
+                path: 'README.md',
+                content: readme,
+                type: 'documentation',
+                language: 'markdown',
+            });
+            // Generate tests (if requested) - Use comprehensive test generator
+            if (options.includeTests) {
+                const testSuite = this.testGenerator.generateLangChainTests(manifest, options.testOptions || {
+                    includeUnit: true,
+                    includeIntegration: true,
+                    includeLoad: true,
+                    includeSecurity: true,
+                    includeCost: true,
+                });
+                // Add all test files
+                files.push(...testSuite.files);
+                files.push(...testSuite.configs);
+                files.push(...testSuite.fixtures);
+            }
+            const duration = Date.now() - startTime;
+            const toolsCount = manifest.spec?.tools?.length || 0;
+            return {
+                success: true,
+                files,
+                metadata: {
+                    pythonVersion,
+                    langchainVersion: '0.1.0',
+                    toolsCount,
+                    memoryType: memoryBackend,
+                    hasApi: includeApi,
+                    hasOpenApi: includeOpenApi,
+                    duration,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                files: [],
+                error: error instanceof Error ? error.message : String(error),
+                metadata: {
+                    pythonVersion: options.pythonVersion || '3.11',
+                    langchainVersion: '0.1.0',
+                    toolsCount: 0,
+                    memoryType: options.memoryBackend || 'buffer',
+                    hasApi: false,
+                    hasOpenApi: false,
+                    duration: Date.now() - startTime,
+                },
+            };
+        }
+    }
+    /**
+     * Validate OSSA manifest for LangChain export
+     */
+    validateManifest(manifest) {
+        if (!manifest.metadata?.name) {
+            throw new Error('Manifest must have metadata.name');
+        }
+        if (!manifest.spec?.role) {
+            throw new Error('Manifest must have spec.role (system prompt)');
+        }
+    }
+    /**
+     * Generate main agent code
+     */
+    generateAgentCode(manifest, options) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const systemPrompt = manifest.spec?.role || '';
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider || 'openai';
+        const model = llm?.model || 'gpt-4';
+        const temperature = llm?.temperature ?? 0.7;
+        const maxTokens = llm?.maxTokens ?? 2000;
+        return `"""
+${agentName} - LangChain Agent
+Generated from OSSA manifest
+
+Description: ${manifest.metadata?.description || 'AI Agent'}
+Version: ${manifest.metadata?.version || '1.0.0'}
+"""
+
+from typing import Any, Dict, List, Optional
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from tools import get_tools
+from memory import get_memory
+from callbacks import get_callbacks, get_cost_tracker, print_cost_summary
+from error_handling import safe_agent_invoke, get_error_stats
+import os
+
+# LLM Configuration
+LLM_PROVIDER = "${provider}"
+LLM_MODEL = "${model}"
+LLM_TEMPERATURE = ${temperature}
+LLM_MAX_TOKENS = ${maxTokens}
+
+
+def create_llm():
+    """Initialize LLM based on provider configuration"""
+    if LLM_PROVIDER == "anthropic":
+        return ChatAnthropic(
+            model=LLM_MODEL,
+            temperature=LLM_TEMPERATURE,
+            max_tokens=LLM_MAX_TOKENS,
+            api_key=os.getenv("ANTHROPIC_API_KEY"),
+        )
+    elif LLM_PROVIDER == "openai":
+        return ChatOpenAI(
+            model=LLM_MODEL,
+            temperature=LLM_TEMPERATURE,
+            max_tokens=LLM_MAX_TOKENS,
+            api_key=os.getenv("OPENAI_API_KEY"),
+        )
+    else:
+        raise ValueError(f"Unsupported LLM provider: {LLM_PROVIDER}")
+
+
+def create_agent() -> AgentExecutor:
+    """Create and configure the LangChain agent"""
+
+    # Initialize LLM
+    llm = create_llm()
+
+    # Get tools
+    tools = get_tools()
+
+    # Create prompt template
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """${systemPrompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"""),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("human", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ])
+
+    # Create agent
+    agent = create_openai_tools_agent(llm, tools, prompt)
+
+    # Get memory
+    memory = get_memory()
+
+    # Get callbacks (observability + cost tracking)
+    callbacks = get_callbacks()
+
+    # Create executor
+    agent_executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        memory=memory,
+        callbacks=callbacks.handlers,
+        verbose=True,
+        handle_parsing_errors=True,
+        max_iterations=10,
+    )
+
+    return agent_executor
+
+
+# Create global agent instance
+agent = create_agent()
+
+
+def run(input_text: str, chat_history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+    """
+    Run the agent with input text (production-grade error handling)
+
+    Args:
+        input_text: User input message
+        chat_history: Optional chat history for context
+
+    Returns:
+        Agent response with output, cost tracking, and error handling
+    """
+    # Use safe invoke with retry, circuit breaker, and fallback
+    result = safe_agent_invoke(
+        agent,
+        input_text,
+        chat_history=chat_history or [],
+    )
+
+    # Add cost tracking to response
+    cost_tracker = get_cost_tracker()
+    result["cost"] = cost_tracker.get_summary()
+
+    return result
+
+
+if __name__ == "__main__":
+    # Example usage
+    print(f"Starting {agentName}...")
+
+    response = run("Hello! What can you help me with?")
+    print(f"Agent: {response['output']}")
+`;
+    }
+    /**
+     * Generate requirements.txt
+     */
+    generateRequirements(manifest, options) {
+        const isMultiAgentWorkflow = this.langGraphGenerator.shouldUseLangGraph(manifest);
+        const requirements = [
+            '# LangChain Core',
+            'langchain>=0.1.0',
+            'langchain-openai>=0.0.5',
+            'langchain-core>=0.1.0',
+            '',
+        ];
+        // Add LangGraph for multi-agent workflows
+        if (isMultiAgentWorkflow) {
+            requirements.push('# LangGraph (Multi-Agent Workflows)', 'langgraph>=0.0.30', '');
+        }
+        requirements.push('# LLM Providers');
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider || 'openai';
+        if (provider === 'anthropic') {
+            requirements.push('langchain-anthropic>=0.1.0');
+        }
+        else if (provider === 'openai') {
+            requirements.push('openai>=1.0.0');
+        }
+        requirements.push('', '# Memory & Storage', 'redis>=5.0.0  # For Redis memory backend', 'psycopg2-binary>=2.9.0  # For Postgres memory backend', '');
+        if (options.includeApi !== false) {
+            requirements.push('# FastAPI Server', 'fastapi>=0.109.0', 'uvicorn[standard]>=0.27.0', 'pydantic>=2.0.0', '');
+        }
+        // Streaming dependencies (always included with API for SSE + WebSocket support)
+        if (options.includeApi !== false) {
+            requirements.push('# Streaming Support (SSE + WebSocket)', 'sse-starlette>=1.8.0  # Server-Sent Events', 'websockets>=12.0  # WebSocket streaming', '');
+        }
+        // Callbacks and observability dependencies
+        const callbacksConfig = options.callbacks;
+        if (callbacksConfig) {
+            requirements.push('# Observability & Callbacks');
+            if (callbacksConfig.langsmith !== false) {
+                requirements.push('langsmith>=0.1.0  # LangSmith tracing');
+            }
+            if (callbacksConfig.langfuse) {
+                requirements.push('langfuse>=2.0.0  # LangFuse observability');
+            }
+            if (callbacksConfig.opentelemetry) {
+                requirements.push('opentelemetry-api>=1.20.0  # OpenTelemetry', 'opentelemetry-sdk>=1.20.0', 'opentelemetry-exporter-otlp>=1.20.0');
+            }
+            requirements.push('');
+        }
+        // Error handling dependencies
+        const errorHandlingConfig = options.errorHandling;
+        if (errorHandlingConfig?.fallback?.useCachedResponses) {
+            requirements.push('# Error Handling', 'cachetools>=5.0.0  # Response caching', '');
+        }
+        // LangServe deployment dependencies
+        if (options.includeLangServe) {
+            requirements.push('# LangServe Deployment', 'langserve[all]>=0.0.30  # LangServe REST API deployment', 'sse-starlette>=1.8.0  # Server-Sent Events for streaming', '');
+        }
+        requirements.push('# Utilities', 'python-dotenv>=1.0.0', 'pyyaml>=6.0.0', 'httpx>=0.26.0', '');
+        return requirements.join('\n');
+    }
+    /**
+     * Generate Dockerfile
+     */
+    generateDockerfile(pythonVersion) {
+        return `FROM python:${pythonVersion}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose API port
+EXPOSE 8000
+
+# Run FastAPI server
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]
+`;
+    }
+    /**
+     * Generate docker-compose.yaml
+     */
+    generateDockerCompose(manifest, options) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const port = options.apiPort || 8000;
+        const memoryBackend = options.memoryBackend || 'buffer';
+        let compose = `version: '3.8'
+
+services:
+  ${agentName}:
+    build: .
+    ports:
+      - "${port}:8000"
+    environment:
+      - OPENAI_API_KEY=\${OPENAI_API_KEY}
+      - ANTHROPIC_API_KEY=\${ANTHROPIC_API_KEY}
+`;
+        if (memoryBackend === 'redis') {
+            compose += `      - REDIS_URL=redis://redis:6379
+    depends_on:
+      - redis
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+`;
+        }
+        else if (memoryBackend === 'postgres') {
+            compose += `      - POSTGRES_URL=postgresql://postgres:postgres@postgres:5432/agent_memory
+    depends_on:
+      - postgres
+
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=agent_memory
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+`;
+        }
+        return compose;
+    }
+    /**
+     * Generate .env.example
+     */
+    generateEnvExample(manifest) {
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider || 'openai';
+        const vars = [
+            '# LLM API Keys',
+            'OPENAI_API_KEY=your-openai-api-key-here',
+            'ANTHROPIC_API_KEY=your-anthropic-api-key-here',
+            '',
+            '# Memory Backend',
+            'REDIS_URL=redis://localhost:6379',
+            'POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/agent_memory',
+            '',
+            '# API Configuration',
+            'API_PORT=8000',
+            'API_HOST=0.0.0.0',
+            '',
+            '# Callbacks & Observability',
+            'CALLBACK_LOG_LEVEL=info  # debug, info, warn, error',
+            '',
+            '# LangSmith (Observability)',
+            'LANGSMITH_ENABLED=true',
+            'LANGCHAIN_API_KEY=your-langsmith-api-key',
+            'LANGCHAIN_PROJECT=default',
+            'LANGCHAIN_ENDPOINT=https://api.smith.langchain.com',
+            '',
+            '# LangFuse (Optional)',
+            'LANGFUSE_ENABLED=false',
+            'LANGFUSE_PUBLIC_KEY=your-public-key',
+            'LANGFUSE_SECRET_KEY=your-secret-key',
+            'LANGFUSE_HOST=https://cloud.langfuse.com',
+            '',
+            '# OpenTelemetry (Optional)',
+            'OTEL_ENABLED=false',
+            'OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317',
+            'OTEL_SERVICE_NAME=langchain-agent',
+            '',
+        ];
+        return vars.join('\n');
+    }
+    /**
+     * Generate README.md
+     */
+    generateReadme(manifest, options) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const description = manifest.metadata?.description || 'AI Agent';
+        const llm = manifest.spec?.llm;
+        const provider = llm?.provider || 'openai';
+        const model = llm?.model || 'gpt-4';
+        const toolsCount = manifest.spec?.tools?.length || 0;
+        const isMultiAgentWorkflow = this.langGraphGenerator.shouldUseLangGraph(manifest);
+        let workflowInfo = '';
+        if (isMultiAgentWorkflow) {
+            const structure = this.langGraphGenerator.analyzeWorkflow(manifest);
+            workflowInfo = `
+- **Workflow Type**: Multi-Agent (LangGraph)
+- **Pattern**: ${structure.pattern}
+- **Agents**: ${structure.agents.length}
+- **Conditional Logic**: ${structure.hasConditionalLogic ? 'Yes' : 'No'}
+- **Human Approval**: ${structure.hasHumanApproval ? 'Yes' : 'No'}`;
+        }
+        return `# ${agentName}
+
+${description}
+
+## Overview
+
+This is a production-ready LangChain agent exported from an OSSA manifest.${isMultiAgentWorkflow ? ' This agent uses **LangGraph** for multi-agent workflow orchestration.' : ''}
+
+**Configuration:**
+- LLM: ${provider} (${model})
+- Tools: ${toolsCount} available
+- Memory: ${options.memoryBackend || 'buffer'}
+- API: ${options.includeApi !== false ? 'FastAPI REST server' : 'No API'}${workflowInfo}
+
+## Setup
+
+### 1. Install Dependencies
+
+\`\`\`bash
+pip install -r requirements.txt
+\`\`\`
+
+### 2. Configure Environment
+
+Copy \`.env.example\` to \`.env\` and add your API keys:
+
+\`\`\`bash
+cp .env.example .env
+# Edit .env with your API keys
+\`\`\`
+
+### 3. Run Agent
+
+**Python CLI:**
+\`\`\`bash
+python agent.py
+\`\`\`
+${isMultiAgentWorkflow ? `
+**LangGraph Workflow:**
+\`\`\`bash
+python langgraph.py
+\`\`\`
+` : ''}
+**FastAPI Server:**
+\`\`\`bash
+uvicorn server:app --reload
+\`\`\`
+
+**Docker:**
+\`\`\`bash
+docker-compose up
+\`\`\`
+
+## API Usage
+
+### POST /chat
+
+Send a message to the agent:
+
+\`\`\`bash
+curl -X POST http://localhost:8000/chat \\
+  -H "Content-Type: application/json" \\
+  -d '{"message": "Hello, agent!"}'
+\`\`\`
+
+### GET /health
+
+Check server health:
+
+\`\`\`bash
+curl http://localhost:8000/health
+\`\`\`
+
+### GET /openapi.json
+
+Get OpenAPI specification:
+
+\`\`\`bash
+curl http://localhost:8000/openapi.json
+\`\`\`
+
+## Development
+
+### Run Tests
+
+\`\`\`bash
+pytest test_agent.py -v
+\`\`\`
+
+### Code Quality
+
+\`\`\`bash
+black .
+ruff check .
+mypy .
+\`\`\`
+
+## Tools
+
+${manifest.spec?.tools?.map((tool) => `- **${tool.name}**: ${tool.description || 'No description'}`).join('\n') || 'No tools configured'}
+
+## Generated from OSSA
+
+- Manifest: \`agent.ossa.yaml\`
+- OSSA Version: ${manifest.apiVersion?.split('/')[1] || 'v0.3.6'}
+- Export Date: ${new Date().toISOString().split('T')[0]}
+
+## License
+
+${manifest.metadata?.license || 'MIT'}
+`;
+    }
+    /**
+     * Generate tests
+     */
+    generateTests(manifest) {
+        const agentName = manifest.metadata?.name || 'agent';
+        return `"""
+Tests for ${agentName}
+"""
+
+import pytest
+from agent import create_agent, run
+
+
+def test_agent_creation():
+    """Test agent can be created"""
+    agent = create_agent()
+    assert agent is not None
+
+
+def test_agent_run():
+    """Test agent can process input"""
+    response = run("Hello!")
+    assert response is not None
+    assert "success" in response
+    assert response["success"] is True
+
+
+def test_agent_error_handling():
+    """Test agent handles errors gracefully"""
+    # This should not crash
+    response = run("")
+    assert response is not None
+
+
+@pytest.mark.parametrize("input_text", [
+    "What can you help me with?",
+    "Tell me about yourself",
+    "What tools do you have?",
+])
+def test_agent_various_inputs(input_text):
+    """Test agent with various inputs"""
+    response = run(input_text)
+    assert response["success"] is True
+    assert len(response.get("output", "")) > 0
+`;
+    }
+    /**
+     * Generate main agent.py wrapper for Plan-and-Execute architecture
+     */
+    generatePlanExecuteMainAgent(manifest) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const description = manifest.metadata?.description || 'AI Agent';
+        const version = manifest.metadata?.version || '1.0.0';
+        return `"""
+${agentName} - Plan-and-Execute Agent
+Generated from OSSA manifest
+
+Description: ${description}
+Version: ${version}
+Architecture: Plan-and-Execute (Planner + Executor)
+"""
+
+from typing import Any, Dict, Optional
+from plan_execute import run as plan_execute_run
+from memory import get_memory
+from callbacks import get_callbacks, get_cost_tracker, print_cost_summary
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def create_agent():
+    """
+    Create Plan-and-Execute agent
+
+    Note: The actual agent is created in plan_execute.py
+    This is a wrapper for compatibility with standard agent interface
+    """
+    logger.info("Plan-and-Execute agent initialized")
+    return {
+        "type": "plan-execute",
+        "components": ["planner", "executor"],
+        "memory": get_memory(),
+        "callbacks": get_callbacks(),
+    }
+
+
+def run(goal: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Run the Plan-and-Execute agent
+
+    Args:
+        goal: The objective to achieve
+        context: Optional context information
+
+    Returns:
+        Execution results with plan and step outputs
+    """
+    logger.info(f"Running Plan-and-Execute agent for goal: {goal}")
+
+    # Delegate to plan_execute module
+    result = plan_execute_run(goal, context)
+
+    # Log cost summary
+    if "cost" in result:
+        logger.info(f"Total cost: {result['cost']}")
+
+    return result
+
+
+if __name__ == "__main__":
+    # Example usage
+    print(f"Starting {agentName} (Plan-and-Execute Architecture)...")
+    print("=" * 60)
+
+    response = run("Research and write a blog post about AI trends in 2024")
+
+    print("\\n" + "=" * 60)
+    print(f"Success: {response['success']}")
+    print(f"\\nFinal Output:")
+    print(response['output'])
+
+    if 'plan' in response:
+        print(f"\\nExecution Plan:")
+        for step in response['plan']['steps']:
+            print(f"  {step['id']}. {step['description']}")
+
+    if 'cost' in response:
+        print(f"\\nCost Summary: {response['cost']}")
+`;
+    }
+}
+//# sourceMappingURL=langchain-exporter.js.map