@bluefly/openstandardagents 0.4.0 → 0.4.2

package/dist/services/export/anthropic/tools-generator.js

@@ -0,0 +1,260 @@
+/**
+ * Anthropic Tools Generator
+ *
+ * Generates Anthropic-compatible tool definitions from OSSA tools.
+ * Supports Claude function calling with proper schema conversion.
+ *
+ * SOLID: Single Responsibility - Tool schema generation only
+ * DRY: Reusable tool conversion logic
+ */
+/**
+ * Generate Anthropic tool definitions from OSSA manifest
+ */
+export function generateTools(manifest) {
+    const tools = [];
+    // Extract from spec.tools
+    if (manifest.spec?.tools && Array.isArray(manifest.spec.tools)) {
+        for (const tool of manifest.spec.tools) {
+            tools.push(convertOssaToolToAnthropic(tool));
+        }
+    }
+    // Extract from extensions.anthropic.tools
+    if (manifest.extensions?.anthropic &&
+        typeof manifest.extensions.anthropic === 'object' &&
+        'tools' in manifest.extensions.anthropic) {
+        const anthropicExt = manifest.extensions.anthropic;
+        if (anthropicExt.tools && Array.isArray(anthropicExt.tools)) {
+            tools.push(...anthropicExt.tools);
+        }
+    }
+    return tools;
+}
+/**
+ * Convert OSSA tool to Anthropic tool format
+ */
+function convertOssaToolToAnthropic(tool) {
+    const name = tool.name || 'unknown_tool';
+    const description = tool.description || `${tool.type || 'Tool'} tool`;
+    // Use inputSchema if available
+    if (tool.inputSchema && typeof tool.inputSchema === 'object') {
+        return {
+            name,
+            description,
+            input_schema: normalizeSchema(tool.inputSchema),
+        };
+    }
+    // Check config.input_schema
+    if (tool.config &&
+        typeof tool.config === 'object' &&
+        'input_schema' in tool.config) {
+        return {
+            name,
+            description,
+            input_schema: normalizeSchema(tool.config.input_schema),
+        };
+    }
+    // Generate schema based on tool type
+    return {
+        name,
+        description,
+        input_schema: generateSchemaForToolType(tool.type || 'function', tool),
+    };
+}
+/**
+ * Normalize schema to Anthropic format
+ */
+function normalizeSchema(schema) {
+    // Ensure schema has required fields
+    const normalized = {
+        type: 'object',
+        properties: {},
+    };
+    if (schema.properties && typeof schema.properties === 'object') {
+        normalized.properties = schema.properties;
+    }
+    if (schema.required && Array.isArray(schema.required)) {
+        normalized.required = schema.required;
+    }
+    return normalized;
+}
+/**
+ * Generate input schema based on tool type
+ */
+function generateSchemaForToolType(type, tool) {
+    switch (type) {
+        case 'mcp':
+            return {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        description: 'MCP action to execute',
+                        enum: tool.capabilities || ['read', 'write', 'execute'],
+                    },
+                    params: {
+                        type: 'object',
+                        description: 'Action parameters',
+                    },
+                },
+                required: ['action'],
+            };
+        case 'http':
+        case 'api':
+            return {
+                type: 'object',
+                properties: {
+                    method: {
+                        type: 'string',
+                        description: 'HTTP method',
+                        enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'API endpoint path',
+                    },
+                    body: {
+                        type: 'object',
+                        description: 'Request body',
+                    },
+                    params: {
+                        type: 'object',
+                        description: 'Query parameters',
+                    },
+                },
+                required: ['method', 'path'],
+            };
+        case 'function':
+        case 'code':
+            return {
+                type: 'object',
+                properties: {
+                    args: {
+                        type: 'object',
+                        description: 'Function arguments',
+                    },
+                },
+            };
+        case 'search':
+            return {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query',
+                    },
+                    filters: {
+                        type: 'object',
+                        description: 'Search filters',
+                    },
+                },
+                required: ['query'],
+            };
+        case 'database':
+            return {
+                type: 'object',
+                properties: {
+                    operation: {
+                        type: 'string',
+                        description: 'Database operation',
+                        enum: ['query', 'insert', 'update', 'delete'],
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Query or command',
+                    },
+                    params: {
+                        type: 'object',
+                        description: 'Query parameters',
+                    },
+                },
+                required: ['operation'],
+            };
+        default:
+            return {
+                type: 'object',
+                properties: {
+                    input: {
+                        type: 'string',
+                        description: 'Tool input',
+                    },
+                },
+            };
+    }
+}
+/**
+ * Generate Python tool definitions code
+ */
+export function generatePythonTools(tools) {
+    if (tools.length === 0) {
+        return 'tools = []';
+    }
+    const toolDefinitions = tools
+        .map((tool) => {
+        const schemaJson = JSON.stringify(tool.input_schema, null, 8);
+        return `    {
+        "name": "${escapeString(tool.name)}",
+        "description": "${escapeString(tool.description)}",
+        "input_schema": ${schemaJson}
+    }`;
+    })
+        .join(',\n');
+    return `tools = [\n${toolDefinitions}\n]`;
+}
+/**
+ * Generate tool handler stubs
+ */
+export function generateToolHandlers(tools) {
+    if (tools.length === 0) {
+        return '';
+    }
+    const handlers = tools
+        .map((tool) => {
+        return `def handle_${tool.name}(input_data: dict) -> str:
+    """
+    Handle ${tool.name} tool execution.
+
+    Args:
+        input_data: Tool input matching the schema
+
+    Returns:
+        Tool execution result as string
+    """
+    # TODO: Implement tool logic
+    return json.dumps({"status": "success", "message": "Not implemented"})
+`;
+    })
+        .join('\n\n');
+    const dispatcher = `
+def handle_tool_use(tool_name: str, tool_input: dict) -> str:
+    """
+    Dispatch tool execution to appropriate handler.
+
+    Args:
+        tool_name: Name of the tool to execute
+        tool_input: Tool input data
+
+    Returns:
+        Tool execution result
+    """
+    handlers = {
+${tools.map((t) => `        "${t.name}": handle_${t.name}`).join(',\n')}
+    }
+
+    handler = handlers.get(tool_name)
+    if not handler:
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})
+
+    try:
+        return handler(tool_input)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+`;
+    return handlers + dispatcher;
+}
+/**
+ * Escape string for Python code generation
+ */
+function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+//# sourceMappingURL=tools-generator.js.map

package/dist/services/export/anthropic/tools-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-generator.js","sourceRoot":"","sources":["../../../../src/services/export/anthropic/tools-generator.ts"],"names":[],"mappings":"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"}

package/dist/services/export/langchain/api-generator.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FastAPI Server Generator
+ *
+ * Generates production-ready FastAPI server for LangChain agents
+ * with /chat endpoint, health checks, and streaming support
+ *
+ * SOLID: Single Responsibility - API server generation
+ * DRY: Reusable API templates
+ */
+import type { OssaAgent } from '../../../types/index.js';
+export declare class ApiGenerator {
+    /**
+     * Generate FastAPI server code
+     */
+    generate(manifest: OssaAgent, port?: number): string;
+}
+//# sourceMappingURL=api-generator.d.ts.map

package/dist/services/export/langchain/api-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-generator.d.ts","sourceRoot":"","sources":["../../../../src/services/export/langchain/api-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qBAAa,YAAY;IACvB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,IAAI,GAAE,MAAa,GAAG,MAAM;CAyW3D"}

package/dist/services/export/langchain/api-generator.js

@@ -0,0 +1,375 @@
+/**
+ * FastAPI Server Generator
+ *
+ * Generates production-ready FastAPI server for LangChain agents
+ * with /chat endpoint, health checks, and streaming support
+ *
+ * SOLID: Single Responsibility - API server generation
+ * DRY: Reusable API templates
+ */
+export class ApiGenerator {
+    /**
+     * Generate FastAPI server code
+     */
+    generate(manifest, port = 8000) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const description = manifest.metadata?.description || 'AI Agent API';
+        const version = manifest.metadata?.version || '1.0.0';
+        return `"""
+FastAPI Server for ${agentName}
+
+${description}
+
+This server provides a REST API for the LangChain agent with:
+- POST /chat - Send messages to the agent
+- POST /chat/stream - Streaming chat responses
+- GET /health - Health check endpoint
+- GET /sessions - List active sessions
+- DELETE /sessions/{session_id} - Clear session history
+
+OpenAPI documentation available at /docs
+"""
+
+from typing import Optional, List, Dict, Any
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect, status
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import uvicorn
+import asyncio
+import json
+import os
+
+from agent import create_agent, run
+from memory import get_memory, clear_memory, get_all_sessions, delete_session
+from streaming import stream_sse, stream_websocket, manager as ws_manager
+from callbacks import get_cost_tracker, print_cost_summary
+
+# FastAPI app
+app = FastAPI(
+    title="${agentName} API",
+    description="${description}",
+    version="${version}",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Agent instance (singleton)
+agent = create_agent()
+
+# Session memories cache
+session_memories: Dict[str, Any] = {}
+
+
+# Request/Response Models
+
+class ChatRequest(BaseModel):
+    """Chat request payload"""
+    message: str = Field(..., description="User message to send to the agent")
+    session_id: Optional[str] = Field(
+        default="default",
+        description="Session ID for conversation context"
+    )
+    stream: Optional[bool] = Field(
+        default=False,
+        description="Enable streaming responses"
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "message": "Hello! What can you help me with?",
+                "session_id": "user-123",
+                "stream": False,
+            }
+        }
+
+
+class ChatResponse(BaseModel):
+    """Chat response payload"""
+    response: str = Field(..., description="Agent's response message")
+    session_id: str = Field(..., description="Session ID")
+    success: bool = Field(..., description="Whether the request succeeded")
+    error: Optional[str] = Field(None, description="Error message if failed")
+    metadata: Optional[Dict[str, Any]] = Field(
+        None,
+        description="Additional metadata (token usage, etc.)"
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "response": "I can help you with various tasks...",
+                "session_id": "user-123",
+                "success": True,
+                "metadata": {
+                    "tokens_used": 150,
+                },
+            }
+        }
+
+
+class HealthResponse(BaseModel):
+    """Health check response"""
+    status: str = Field(..., description="Service status")
+    agent: str = Field(..., description="Agent name")
+    version: str = Field(..., description="API version")
+
+
+class SessionInfo(BaseModel):
+    """Session information"""
+    session_id: str = Field(..., description="Session identifier")
+    message_count: Optional[int] = Field(None, description="Number of messages")
+
+
+# Endpoints
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest) -> ChatResponse:
+    """
+    Send a message to the agent
+
+    Args:
+        request: Chat request with message and optional session ID
+
+    Returns:
+        Agent response with conversation context
+
+    Raises:
+        HTTPException: If agent execution fails
+    """
+    try:
+        # Get or create session memory
+        session_id = request.session_id or "default"
+
+        if session_id not in session_memories:
+            session_memories[session_id] = get_memory(session_id)
+
+        memory = session_memories[session_id]
+
+        # Run agent
+        result = run(request.message)
+
+        if not result.get("success"):
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=result.get("error", "Agent execution failed"),
+            )
+
+        return ChatResponse(
+            response=result.get("output", ""),
+            session_id=session_id,
+            success=True,
+            metadata={
+                "tokens_used": result.get("tokens_used"),
+            },
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e),
+        )
+
+
+@app.post("/chat/stream")
+async def chat_stream(request: ChatRequest):
+    """
+    Stream chat responses from the agent via SSE with real-time cost tracking
+
+    Args:
+        request: Chat request with message and session ID
+
+    Returns:
+        Server-sent events stream with agent response tokens and cost information
+    """
+    try:
+        session_id = request.session_id or "default"
+        cost_tracker = get_cost_tracker()
+
+        # Use the streaming module's SSE implementation
+        return StreamingResponse(
+            stream_sse(request.message, agent, session_id, cost_tracker),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+                "Access-Control-Allow-Origin": "*",
+            }
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Streaming error: {str(e)}"
+        )
+
+
+@app.websocket("/chat/ws")
+async def chat_websocket(websocket: WebSocket, session_id: str = "default"):
+    """
+    WebSocket endpoint for bidirectional streaming with cancellation support
+
+    Args:
+        websocket: WebSocket connection
+        session_id: Session identifier for conversation context
+
+    WebSocket Message Format (Client -> Server):
+        {
+            "type": "message",  # or "cancel"
+            "message": "user message text"
+        }
+
+    WebSocket Message Format (Server -> Client):
+        {
+            "type": "token",  # or "llm_start", "llm_end", "done", "error", "cancelled"
+            "token": "response token",
+            "token_count": 42,
+            "cost": 0.00123
+        }
+    """
+    await stream_websocket(websocket, agent, session_id)
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health() -> HealthResponse:
+    """
+    Health check endpoint
+
+    Returns:
+        Service health status
+    """
+    return HealthResponse(
+        status="healthy",
+        agent="${agentName}",
+        version="${version}",
+    )
+
+
+@app.get("/sessions", response_model=List[SessionInfo])
+async def list_sessions() -> List[SessionInfo]:
+    """
+    List all active sessions
+
+    Returns:
+        List of session IDs with metadata
+    """
+    try:
+        sessions = get_all_sessions()
+        return [
+            SessionInfo(session_id=session_id)
+            for session_id in sessions
+        ]
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to list sessions: {str(e)}",
+        )
+
+
+@app.delete("/sessions/{session_id}")
+async def clear_session(session_id: str) -> JSONResponse:
+    """
+    Clear conversation history for a session
+
+    Args:
+        session_id: Session identifier to clear
+
+    Returns:
+        Success confirmation
+    """
+    try:
+        if session_id in session_memories:
+            clear_memory(session_memories[session_id], session_id)
+            del session_memories[session_id]
+
+        delete_session(session_id)
+
+        return JSONResponse(
+            content={
+                "status": "success",
+                "message": f"Session {session_id} cleared",
+            }
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to clear session: {str(e)}",
+        )
+
+
+@app.get("/cost-summary")
+async def get_cost_summary():
+    """
+    Get cost tracking summary for the current session
+
+    Returns:
+        Token usage and cost information
+    """
+    cost_tracker = get_cost_tracker()
+    return cost_tracker.get_summary()
+
+
+@app.post("/cost-summary/reset")
+async def reset_cost_summary():
+    """
+    Reset cost tracking counters
+
+    Returns:
+        Confirmation message
+    """
+    cost_tracker = get_cost_tracker()
+    cost_tracker.reset()
+    return {"status": "success", "message": "Cost tracking reset"}
+
+
+@app.get("/")
+async def root():
+    """
+    API root endpoint
+
+    Returns:
+        Welcome message with links to documentation
+    """
+    return {
+        "message": "Welcome to ${agentName} API",
+        "version": "${version}",
+        "docs": "/docs",
+        "openapi": "/openapi.json",
+        "health": "/health",
+        "endpoints": {
+            "chat": "/chat",
+            "stream_sse": "/chat/stream",
+            "stream_ws": "/chat/ws",
+            "cost_summary": "/cost-summary",
+        }
+    }
+
+
+# Run server
+if __name__ == "__main__":
+    port = int(os.getenv("API_PORT", ${port}))
+    host = os.getenv("API_HOST", "0.0.0.0")
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info",
+    )
+`;
+    }
+}
+//# sourceMappingURL=api-generator.js.map

package/dist/services/export/langchain/api-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-generator.js","sourceRoot":"","sources":["../../../../src/services/export/langchain/api-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,OAAO,YAAY;IACvB;;OAEG;IACH,QAAQ,CAAC,QAAmB,EAAE,OAAe,IAAI;QAC/C,MAAM,SAAS,GAAG,QAAQ,CAAC,QAAQ,EAAE,IAAI,IAAI,OAAO,CAAC;QACrD,MAAM,WAAW,GAAG,QAAQ,CAAC,QAAQ,EAAE,WAAW,IAAI,cAAc,CAAC;QACrE,MAAM,OAAO,GAAG,QAAQ,CAAC,QAAQ,EAAE,OAAO,IAAI,OAAO,CAAC;QAEtD,OAAO;qBACU,SAAS;;EAE5B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA6BA,SAAS;mBACH,WAAW;eACf,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4ML,SAAS;mBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA0FO,SAAS;sBACpB,OAAO;;;;;;;;;;;;;;;uCAeU,IAAI;;;;;;;;;CAS1C,CAAC;IACA,CAAC;CACF"}