@bluefly/openstandardagents 0.2.5-RC → 0.2.7

package/website/content/docs/documentation.md

@@ -0,0 +1,100 @@
+---
+title: Documentation
+description: Complete OSSA documentation with auto-generated API, CLI, and schema references
+---
+
+# OSSA Documentation
+
+Welcome to the complete OSSA documentation. All reference documentation is **auto-generated** from source code and specifications.
+
+## 📚 Documentation Sections
+
+### [CLI Reference](/docs/cli-reference)
+Complete reference for all OSSA CLI commands with examples.
+
+**11 Commands Documented:**
+- [ossa validate](/docs/cli-reference/ossa-validate) - Validate agent manifests
+- [ossa generate](/docs/cli-reference/ossa-generate) - Generate agent templates
+- [ossa run](/docs/cli-reference/ossa-run) - Run agents locally
+- [ossa migrate](/docs/cli-reference/ossa-migrate) - Migrate between versions
+- [ossa init](/docs/cli-reference/ossa-init) - Initialize projects
+- [ossa setup](/docs/cli-reference/ossa-setup) - Setup environment
+- [ossa export](/docs/cli-reference/ossa-export) - Export manifests
+- [ossa import](/docs/cli-reference/ossa-import) - Import from frameworks
+- [ossa schema](/docs/cli-reference/ossa-schema) - View schemas
+- [ossa gitlab-agent](/docs/cli-reference/ossa-gitlab-agent) - GitLab integration
+- [ossa agents](/docs/cli-reference/ossa-agents) - Manage agents
+
+### [API Reference](/docs/api-reference)
+Complete REST API documentation with endpoints, examples, and authentication.
+
+**4 Core APIs Documented:**
+- [OSSA Core API](/docs/api-reference/ossa-core-api) - Agent management
+- [OSSA Registry API](/docs/api-reference/ossa-registry-api) - Agent registry
+- [Unified Agent Gateway](/docs/api-reference/unified-agent-gateway) - Gateway API
+
+### [Schema Reference](/docs/schema-reference)
+Complete schema documentation explaining why, how, and where to use each field.
+
+**Key Fields Documented:**
+- [agent.id](/docs/schema-reference/agent-id) - Unique identifier
+- [agent.name](/docs/schema-reference/agent-name) - Human-readable name
+- [agent.version](/docs/schema-reference/agent-version) - Semantic version
+- [agent.role](/docs/schema-reference/agent-role) - Agent classification
+- [agent.capabilities](/docs/schema-reference/agent-capabilities) - What agents can do
+
+## 🚀 Quick Start
+
+```bash
+# Install OSSA CLI
+npm install -g @bluefly/openstandardagents
+
+# Validate an agent
+ossa validate agent.ossa.yaml
+
+# Generate a new agent
+ossa generate worker --name "My Agent"
+
+# Run an agent locally
+ossa run agent.ossa.yaml
+```
+
+## 🤖 Auto-Generated Documentation
+
+All reference documentation is automatically generated from:
+- **CLI Docs**: Generated from `src/cli/commands/*.ts`
+- **API Docs**: Generated from `openapi/core/*.yaml`
+- **Schema Docs**: Generated from `spec/v*/ossa-*.schema.json`
+
+Documentation stays in sync with code through:
+- GitLab CI/CD pipeline
+- Documentation agent (OSSA-compliant)
+- Automated validation and deployment
+
+## 📖 Additional Resources
+
+- [Getting Started](/docs/getting-started) - Quick start guide
+- [Architecture](/docs/architecture) - System architecture
+- [Migration Guides](/docs/migration-guides) - Framework migrations
+- [Examples](/docs/examples) - Real-world examples
+
+## 🔄 Documentation Updates
+
+Documentation is automatically updated when:
+- OpenAPI specifications change
+- CLI commands are modified
+- JSON Schema is updated
+
+**Last Generated**: {new Date().toISOString()}
+
+## 💡 Contributing to Documentation
+
+See our [Documentation Implementation Guide](https://github.com/blueflyio/openstandardagents/blob/main/DOCUMENTATION_IMPLEMENTATION_GUIDE.md) for:
+- Documentation standards
+- Template usage
+- Automation setup
+- Contributing guidelines
+
+---
+
+**Questions?** Open an issue on [GitLab](https://gitlab.com/blueflyio/openstandardagents/-/issues) with the `documentation` label.

package/website/content/docs/ecosystem/framework-support.md

@@ -7,17 +7,92 @@ description: Detailed framework compatibility guide including migration paths, e
 
 This guide provides detailed information about OSSA compatibility with popular AI agent frameworks, including migration guides, examples, and best practices for each integration.
 
+## How OSSA Works
+
+OSSA acts as a **translation layer** between your agent definitions and framework-specific implementations. It doesn't replace frameworks—it standardizes how agents are defined, enabling portability across different execution environments.
+
+### Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    OSSA Manifest (JSON/YAML)                │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │ {                                                     │  │
+│  │   "ossa": "1.0.0",                                   │  │
+│  │   "name": "research-agent",                          │  │
+│  │   "capabilities": { "tools": [...], "llm": {...} }  │  │
+│  │ }                                                     │  │
+│  └──────────────────────────────────────────────────────┘  │
+└────────────────────────┬────────────────────────────────────┘
+                         │
+                         ▼
+         ┌───────────────────────────────┐
+         │   OSSA Runtime / Adapter      │
+         │  (Validates & Translates)     │
+         └───────────────┬───────────────┘
+                         │
+        ┌────────────────┼────────────────┐
+        │                │                │
+        ▼                ▼                ▼
+   ┌─────────┐     ┌──────────┐    ┌──────────┐
+   │LangChain│     │  CrewAI  │    │  AutoGen │
+   └────┬────┘     └─────┬────┘    └─────┬────┘
+        │                │                │
+        └────────────────┼────────────────┘
+                         │
+                         ▼
+              ┌──────────────────┐
+              │   LLM Provider   │
+              │ (OpenAI/Anthropic)│
+              └──────────────────┘
+```
+
+### Data Flow
+
+**1. Manifest Loading**
+```
+OSSA Manifest → Schema Validation → Parsed Configuration
+```
+
+**2. Runtime Translation**
+```
+OSSA Config → Framework Adapter → Native Framework Objects
+```
+
+**3. Execution**
+```
+User Input → Agent Execution → Tool Calls → LLM Responses → Output
+```
+
+**4. Response Flow**
+```
+┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
+│   User   │────▶│   OSSA   │────▶│Framework │────▶│   LLM    │
+│  Input   │     │  Agent   │     │ Runtime  │     │ Provider │
+└──────────┘     └──────────┘     └──────────┘     └──────────┘
+     ▲                                                     │
+     │                                                     │
+     └─────────────────────────────────────────────────────┘
+                    Formatted Response
+```
+
 ## Support Matrix
 
 | Framework | Status | OSSA Version | Migration Complexity | Documentation |
 |-----------|--------|--------------|---------------------|---------------|
 | kAgent | ✅ Native | 1.0.0+ | N/A (Native) | [Docs](#kagent) |
 | LangChain | ✅ Supported | 1.0.0+ | Low | [Docs](#langchain) |
+| LangGraph | ✅ Supported | 1.0.0+ | Low | [Docs](#langgraph) |
 | CrewAI | ✅ Supported | 1.0.0+ | Medium | [Docs](#crewai) |
+| AutoGen | ✅ Supported | 1.0.0+ | Medium | [Docs](#autogen) |
+| Semantic Kernel | ✅ Supported | 1.0.0+ | Medium | [Docs](#semantic-kernel) |
 | Anthropic MCP | ✅ Supported | 1.0.0+ | Low | [Docs](#anthropic-mcp) |
 | Langflow | ✅ Supported | 1.0.0+ | Low | [Docs](#langflow) |
+| LlamaIndex | ✅ Supported | 1.0.0+ | Low | [Docs](#llamaindex) |
+| Haystack | 🔄 Planned | 1.1.0+ | Medium | Coming Soon |
 | Drupal ECA | ✅ Supported | 1.0.0+ | Medium | [Docs](#drupal-eca) |
 | OpenAI Assistants | ✅ Supported | 1.0.0+ | Medium | [Docs](#openai-assistants) |
+| Vercel AI SDK | 🔄 Planned | 1.1.0+ | Low | Coming Soon |
 
 **Legend:**
 - ✅ **Native**: Built on OSSA from the ground up
@@ -26,6 +101,14 @@ This guide provides detailed information about OSSA compatibility with popular A
 - ⚠️ **Beta**: Experimental support available
 - ❌ **Not Supported**: No current integration plans
 
+### What "Supported" Means
+
+**Bidirectional Conversion**: Convert to/from OSSA manifests
+**Runtime Compatibility**: Execute OSSA manifests natively
+**Tool Mapping**: Framework tools map to OSSA tool definitions
+**LLM Configuration**: Framework LLM settings translate to OSSA capabilities
+**Workflow Preservation**: Multi-step workflows maintain structure
+
 ---
 
 ## kAgent {#kagent}
@@ -240,6 +323,371 @@ See [examples/langchain/](https://github.com/blueflyio/openstandardagents/tree/m
 
 ---
 
+## LangGraph {#langgraph}
+
+### Overview
+
+**LangGraph** is LangChain's framework for building stateful, multi-actor applications with LLMs. OSSA supports LangGraph's graph-based workflows with state management.
+
+### Migration Complexity
+
+**Low** - LangGraph's nodes and edges map to OSSA workflow steps.
+
+### Installation
+
+```bash
+npm install @ossa/langgraph langgraph
+# or
+pip install ossa-langgraph langgraph
+```
+
+### Converting LangGraph to OSSA
+
+```python
+from ossa_langgraph import LangGraphToOSSA
+from langgraph.graph import StateGraph, END
+from typing import TypedDict
+
+# Define state
+class AgentState(TypedDict):
+    messages: list
+    next_step: str
+
+# Create graph
+workflow = StateGraph(AgentState)
+
+# Add nodes
+workflow.add_node("researcher", research_node)
+workflow.add_node("writer", write_node)
+workflow.add_node("reviewer", review_node)
+
+# Add edges
+workflow.add_edge("researcher", "writer")
+workflow.add_edge("writer", "reviewer")
+workflow.add_conditional_edges("reviewer", should_continue, {
+    "continue": "writer",
+    "end": END
+})
+
+# Set entry point
+workflow.set_entry_point("researcher")
+
+# Compile
+app = workflow.compile()
+
+# Convert to OSSA
+converter = LangGraphToOSSA()
+manifest = converter.convert(app, name="content-pipeline")
+manifest.save("content-pipeline.json")
+```
+
+### Technical Details
+
+**State Management**: LangGraph state is preserved in OSSA's `workflow.state` field
+**Conditional Routing**: Conditional edges become OSSA workflow conditions
+**Checkpointing**: LangGraph checkpoints map to OSSA's persistence layer
+
+### Data Flow
+
+```
+Input → Entry Node → [State Update] → Next Node → [Condition Check] → 
+  ├─ Continue → Loop Back
+  └─ End → Output
+```
+
+### Documentation
+
+- **LangGraph Docs**: [langchain-ai.github.io/langgraph](https://langchain-ai.github.io/langgraph)
+- **OSSA LangGraph Guide**: [docs.openstandardagents.org/langgraph](https://openstandardagents.org/docs/langgraph)
+
+---
+
+## AutoGen {#autogen}
+
+### Overview
+
+**Microsoft AutoGen** enables multi-agent conversations with human-in-the-loop capabilities. OSSA supports AutoGen's conversational patterns and agent groups.
+
+### Migration Complexity
+
+**Medium** - AutoGen's conversation-driven model requires mapping to OSSA's message-based workflow.
+
+### Installation
+
+```bash
+pip install ossa-autogen pyautogen
+```
+
+### Converting AutoGen to OSSA
+
+```python
+from ossa_autogen import AutoGenToOSSA
+import autogen
+
+# Configure AutoGen agents
+config_list = [{"model": "gpt-4", "api_key": "..."}]
+
+assistant = autogen.AssistantAgent(
+    name="assistant",
+    llm_config={"config_list": config_list},
+)
+
+user_proxy = autogen.UserProxyAgent(
+    name="user_proxy",
+    human_input_mode="NEVER",
+    code_execution_config={"work_dir": "coding"},
+)
+
+# Convert to OSSA
+converter = AutoGenToOSSA()
+manifest = converter.convert(
+    agents=[assistant, user_proxy],
+    name="coding-assistant"
+)
+manifest.save("coding-assistant.json")
+```
+
+### Technical Details
+
+**Conversation Flow**: AutoGen conversations become OSSA workflow steps
+**Code Execution**: AutoGen's code execution maps to OSSA's `code_interpreter` tool
+**Human-in-Loop**: AutoGen's human input becomes OSSA's `approval_required` flag
+
+### Data Flow
+
+```
+User Message → Agent 1 → [Generate Response] → Agent 2 → 
+  [Execute Code] → [Validate] → Agent 1 → Final Response
+```
+
+### Example Manifest
+
+```json
+{
+  "ossa": "1.0.0",
+  "name": "coding-assistant",
+  "type": "orchestrator",
+  "agents": [
+    {
+      "id": "assistant",
+      "role": "Assistant",
+      "capabilities": {
+        "tools": ["code_interpreter"],
+        "llm": {
+          "provider": "openai",
+          "model": "gpt-4"
+        }
+      }
+    },
+    {
+      "id": "executor",
+      "role": "Code Executor",
+      "capabilities": {
+        "tools": [
+          {
+            "type": "code_interpreter",
+            "languages": ["python", "javascript"],
+            "sandbox": true
+          }
+        ]
+      }
+    }
+  ],
+  "workflow": {
+    "type": "conversation",
+    "max_turns": 10,
+    "termination": {
+      "condition": "task_complete"
+    }
+  }
+}
+```
+
+### Documentation
+
+- **AutoGen Docs**: [microsoft.github.io/autogen](https://microsoft.github.io/autogen)
+- **OSSA AutoGen Guide**: [docs.openstandardagents.org/autogen](https://openstandardagents.org/docs/autogen)
+
+---
+
+## Semantic Kernel {#semantic-kernel}
+
+### Overview
+
+**Microsoft Semantic Kernel** is an SDK for integrating LLMs with conventional programming languages. OSSA supports Semantic Kernel's plugin system and planners.
+
+### Migration Complexity
+
+**Medium** - Semantic Kernel's plugin architecture requires mapping to OSSA tools.
+
+### Installation
+
+```bash
+dotnet add package OSSA.SemanticKernel
+# or
+pip install ossa-semantic-kernel semantic-kernel
+```
+
+### Converting Semantic Kernel to OSSA
+
+```csharp
+using Microsoft.SemanticKernel;
+using OSSA.SemanticKernel;
+
+// Create Semantic Kernel
+var kernel = Kernel.CreateBuilder()
+    .AddOpenAIChatCompletion("gpt-4", "api-key")
+    .Build();
+
+// Import plugins
+kernel.ImportPluginFromType<MathPlugin>();
+kernel.ImportPluginFromType<FileIOPlugin>();
+
+// Convert to OSSA
+var converter = new SemanticKernelToOSSA();
+var manifest = converter.Convert(kernel, "sk-agent");
+await manifest.SaveAsync("sk-agent.json");
+```
+
+### Python Example
+
+```python
+from ossa_semantic_kernel import SemanticKernelToOSSA
+import semantic_kernel as sk
+
+# Create kernel
+kernel = sk.Kernel()
+
+# Add service
+kernel.add_chat_service(
+    "chat",
+    sk.connectors.ai.OpenAIChatCompletion("gpt-4", "api-key")
+)
+
+# Import skills
+kernel.import_skill(MathSkill(), "math")
+kernel.import_skill(FileIOSkill(), "fileio")
+
+# Convert to OSSA
+converter = SemanticKernelToOSSA()
+manifest = converter.convert(kernel, name="sk-agent")
+manifest.save("sk-agent.json")
+```
+
+### Technical Details
+
+**Plugin Mapping**: SK plugins become OSSA tools
+**Planner Integration**: SK planners map to OSSA's workflow orchestration
+**Memory**: SK memory becomes OSSA's context management
+
+### Data Flow
+
+```
+User Goal → Planner → [Generate Steps] → Execute Plugin 1 → 
+  Execute Plugin 2 → [Aggregate Results] → Response
+```
+
+### Documentation
+
+- **Semantic Kernel Docs**: [learn.microsoft.com/semantic-kernel](https://learn.microsoft.com/semantic-kernel)
+- **OSSA SK Guide**: [docs.openstandardagents.org/semantic-kernel](https://openstandardagents.org/docs/semantic-kernel)
+
+---
+
+## LlamaIndex {#llamaindex}
+
+### Overview
+
+**LlamaIndex** (formerly GPT Index) is a data framework for LLM applications. OSSA supports LlamaIndex's indexing and query engines.
+
+### Migration Complexity
+
+**Low** - LlamaIndex's query engines map cleanly to OSSA's retrieval tools.
+
+### Installation
+
+```bash
+pip install ossa-llamaindex llama-index
+```
+
+### Converting LlamaIndex to OSSA
+
+```python
+from ossa_llamaindex import LlamaIndexToOSSA
+from llama_index import VectorStoreIndex, SimpleDirectoryReader
+
+# Create index
+documents = SimpleDirectoryReader('data').load_data()
+index = VectorStoreIndex.from_documents(documents)
+
+# Create query engine
+query_engine = index.as_query_engine()
+
+# Convert to OSSA
+converter = LlamaIndexToOSSA()
+manifest = converter.convert(
+    query_engine,
+    name="rag-agent",
+    description="RAG-powered Q&A agent"
+)
+manifest.save("rag-agent.json")
+```
+
+### Technical Details
+
+**Index Types**: Vector, tree, keyword, and graph indexes all supported
+**Retrievers**: LlamaIndex retrievers become OSSA retrieval tools
+**Response Synthesis**: Synthesis modes map to OSSA's response formatting
+
+### Data Flow
+
+```
+Query → [Embed Query] → Vector Search → [Retrieve Docs] → 
+  LLM Context → [Generate Response] → Post-process → Output
+```
+
+### Example Manifest
+
+```json
+{
+  "ossa": "1.0.0",
+  "name": "rag-agent",
+  "type": "worker",
+  "capabilities": {
+    "tools": [
+      {
+        "type": "retrieval",
+        "name": "vector_search",
+        "index_type": "vector",
+        "embedding_model": "text-embedding-ada-002",
+        "top_k": 5
+      }
+    ],
+    "llm": {
+      "provider": "openai",
+      "model": "gpt-4",
+      "temperature": 0.7
+    }
+  },
+  "data": {
+    "sources": [
+      {
+        "type": "directory",
+        "path": "./data",
+        "file_types": ["txt", "pdf", "md"]
+      }
+    ]
+  }
+}
+```
+
+### Documentation
+
+- **LlamaIndex Docs**: [docs.llamaindex.ai](https://docs.llamaindex.ai)
+- **OSSA LlamaIndex Guide**: [docs.openstandardagents.org/llamaindex](https://openstandardagents.org/docs/llamaindex)
+
+---
+
 ## CrewAI {#crewai}
 
 ### Overview
@@ -737,15 +1185,109 @@ console.log(`Created assistant: ${assistant.id}`);
 
 ## Framework Comparison
 
-| Feature | kAgent | LangChain | CrewAI | MCP | Langflow | Drupal ECA | OpenAI |
-|---------|--------|-----------|--------|-----|----------|------------|--------|
-| OSSA Native | ✅ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
-| Multi-Agent | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
-| Visual Builder | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
-| TypeScript | ✅ | ✅ | ❌ | ✅ | ❌ | ❌ | ✅ |
-| Python | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
-| Self-Hosted | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
-| Cloud Managed | ✅ | ✅ | ✅ | ❌ | ✅ | ❌ | ✅ |
+| Feature | kAgent | LangChain | LangGraph | CrewAI | AutoGen | Semantic Kernel | MCP | Langflow | LlamaIndex | Drupal ECA | OpenAI |
+|---------|--------|-----------|-----------|--------|---------|-----------------|-----|----------|------------|------------|--------|
+| OSSA Native | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | ❌ |
+| Multi-Agent | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | ❌ |
+| State Management | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | ✅ |
+| Visual Builder | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ✅ | ❌ |
+| TypeScript | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | ✅ |
+| Python | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
+| C# / .NET | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ |
+| Self-Hosted | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
+| Cloud Managed | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | ❌ | ✅ | ✅ | ❌ | ✅ |
+| RAG Support | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
+| Code Execution | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ |
+
+---
+
+## Technical Architecture
+
+### OSSA Runtime Components
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      OSSA Runtime                            │
+│                                                              │
+│  ┌────────────────┐  ┌────────────────┐  ┌──────────────┐  │
+│  │ Manifest       │  │ Schema         │  │ Validator    │  │
+│  │ Parser         │──│ Validator      │──│ Engine       │  │
+│  └────────────────┘  └────────────────┘  └──────────────┘  │
+│           │                                       │          │
+│           ▼                                       ▼          │
+│  ┌────────────────┐                    ┌──────────────────┐ │
+│  │ Framework      │                    │ Execution        │ │
+│  │ Adapter        │◀───────────────────│ Engine           │ │
+│  └────────────────┘                    └──────────────────┘ │
+│           │                                       │          │
+└───────────┼───────────────────────────────────────┼──────────┘
+            │                                       │
+            ▼                                       ▼
+   ┌────────────────┐                    ┌──────────────────┐
+   │ Native         │                    │ Tool             │
+   │ Framework      │                    │ Registry         │
+   └────────────────┘                    └──────────────────┘
+```
+
+### Adapter Pattern
+
+Each framework adapter implements:
+
+1. **Manifest Translation**: OSSA → Framework Config
+2. **Tool Mapping**: OSSA tools → Framework tools
+3. **Execution Bridge**: Framework execution → OSSA responses
+4. **State Management**: Framework state ↔ OSSA state
+
+### Example: LangChain Adapter Flow
+
+```
+OSSA Manifest
+     │
+     ▼
+┌─────────────────────┐
+│ Parse Capabilities  │
+│ - tools: [...]      │
+│ - llm: {...}        │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Create LangChain    │
+│ - ChatModel         │
+│ - Tools             │
+│ - Agent Executor    │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Execute Task        │
+│ - Input → Agent     │
+│ - Agent → Tools     │
+│ - Tools → LLM       │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Format Response     │
+│ - OSSA Output       │
+└─────────────────────┘
+```
+
+### Tool Resolution
+
+```
+OSSA Tool Definition
+     │
+     ├─ type: "function" ──→ Native Function Call
+     │
+     ├─ type: "mcp" ──────→ MCP Server Connection
+     │
+     ├─ type: "rest" ─────→ HTTP API Call
+     │
+     ├─ type: "retrieval" ─→ Vector DB Query
+     │
+     └─ type: "code" ─────→ Code Interpreter
+```
 
 ---