agentx-sdk 0.2.1 → 0.3.1

package/README.md

@@ -1,5 +1,595 @@
 # AgentX SDK
 
+TypeScript library for building conversational agents with LLMs. Streaming-first, tools, memory, knowledge/RAG, skills and MCP — all in-process, no frameworks.
+
+```bash
+npm install agentx-sdk
+```
+
+## Quick Start
+
+```typescript
+import { Agent } from 'agentx-sdk';
+
+// Works with any OpenAI-compatible API (OpenRouter, OpenAI, Azure, Groq, etc.)
+const agent = Agent.create({
+  apiKey: process.env.LLM_API_KEY!,
+  // baseUrl: 'https://api.openai.com/v1',  // optional — defaults to OpenRouter
+  // model: 'gpt-4o',                        // optional — defaults to Claude Sonnet
+});
+
+// Simple chat
+const response = await agent.chat('What is the capital of France?');
+
+// Streaming
+for await (const event of agent.stream('Explain recursion')) {
+  if (event.type === 'text_delta') process.stdout.write(event.content);
+}
+
+// Separate embedding provider (e.g. OpenAI direct for lower latency)
+const agentWithEmbeddings = Agent.create({
+  apiKey: process.env.LLM_API_KEY!,
+  embedding: {
+    apiKey: process.env.OPENAI_API_KEY!,
+    baseUrl: 'https://api.openai.com/v1',
+    model: 'text-embedding-3-small',
+  },
+});
+```
+
+## Tools
+
+```typescript
+import { z } from 'zod';
+
+agent.addTool({
+  name: 'weather',
+  description: 'Get current weather for a city',
+  parameters: z.object({ city: z.string() }),
+  execute: async ({ city }) => {
+    const res = await fetch(`https://api.weather.com/${city}`);
+    return await res.text();
+  },
+});
+
+await agent.chat('What is the weather in Sao Paulo?');
+// The agent decides to call the tool automatically
+```
+
+### Builtin Tools
+
+The SDK includes ready-to-use tools — filesystem, shell, web and interaction:
+
+```typescript
+import { Agent, builtinTools } from 'agentx-sdk';
+
+const agent = Agent.create({ apiKey: '...' });
+
+// Register all (except askUser which needs a callback)
+builtinTools.all().forEach(t => agent.addTool(t));
+
+// Or register individually
+agent.addTool(builtinTools.fileRead());
+agent.addTool(builtinTools.fileWrite());
+agent.addTool(builtinTools.fileEdit());
+agent.addTool(builtinTools.glob());
+agent.addTool(builtinTools.grep());
+agent.addTool(builtinTools.bash());
+agent.addTool(builtinTools.webFetch());
+
+// askUser needs a callback — you implement the interaction
+agent.addTool(builtinTools.askUser({
+  onAsk: async (question, options) => {
+    // Your logic (readline, UI, API, etc.)
+    return readline.question(question);
+  },
+}));
+
+// Shortcut: file ops only (read + write + edit + glob + grep)
+builtinTools.fileOps().forEach(t => agent.addTool(t));
+```
+
+| Tool | Name | Description |
+|------|------|-------------|
+| `builtinTools.fileRead()` | Read | Read files with line numbers and offset/limit |
+| `builtinTools.fileWrite()` | Write | Write/create files (creates dirs automatically) |
+| `builtinTools.fileEdit()` | Edit | Exact find/replace in files |
+| `builtinTools.glob()` | Glob | Search files by pattern (`**/*.ts`) |
+| `builtinTools.grep()` | Grep | Search content via regex in files |
+| `builtinTools.bash()` | Bash | Execute shell commands with timeout |
+| `builtinTools.webFetch()` | WebFetch | Fetch content from URL (HTML → text) |
+| `builtinTools.askUser()` | AskUser | Ask the user a question (callback pattern) |
+
+## Skills
+
+Skills are modular behaviors that modify the agent when activated. Unlike tools (which the LLM calls to obtain data), skills **inject instructions into the context** to guide LLM behavior.
+
+### Programmatic skill
+
+```typescript
+agent.addSkill({
+  name: 'code-review',
+  description: 'Reviews code for quality and bugs',
+  instructions: `You are in code review mode.
+    Analyze for bugs, security issues, and performance.
+    Rate quality from 1-10.`,
+  triggerPrefix: '/review',
+});
+
+await agent.chat('/review function add(a, b) { return a + b; }');
+```
+
+### Skill with arguments
+
+```typescript
+agent.addSkill({
+  name: 'translate',
+  description: 'Translates text to a target language',
+  instructions: 'Translate the following to $lang: $ARGS',
+  argNames: ['lang'],
+  triggerPrefix: '/translate',
+});
+
+// $lang = "pt", $ARGS = "Hello world"
+await agent.chat('/translate pt Hello world');
+```
+
+### Skill with dynamic prompt
+
+```typescript
+agent.addSkill({
+  name: 'explain',
+  description: 'Explains code at different levels',
+  instructions: '',
+  triggerPrefix: '/explain',
+  argNames: ['level'],
+  getPrompt: async (args, ctx) => {
+    const level = args.split(' ')[0] || 'intermediate';
+    return `Explain for a ${level} developer. Thread: ${ctx.threadId}`;
+  },
+});
+
+await agent.chat('/explain beginner What is a closure?');
+```
+
+### Skill with its own tools
+
+Tools registered in the skill are activated **only when the skill is active** and removed at the end of the turn.
+
+```typescript
+agent.addSkill({
+  name: 'file-manager',
+  description: 'File management operations',
+  instructions: 'You can read files using the read_file tool.',
+  triggerPrefix: '/files',
+  tools: [
+    {
+      name: 'read_file',
+      description: 'Read a file from disk',
+      parameters: z.object({ path: z.string() }),
+      execute: async ({ path }) => {
+        const fs = await import('fs/promises');
+        return fs.readFile(path as string, 'utf-8');
+      },
+    },
+  ],
+});
+```
+
+### Skill with model discovery (whenToUse)
+
+Skills with `whenToUse` are listed in the model context so it can proactively suggest them.
+
+```typescript
+agent.addSkill({
+  name: 'deploy',
+  description: 'Deploy to production',
+  whenToUse: 'When user mentions deploy, release, ship, or push to prod',
+  instructions: 'Guide the user through deployment steps...',
+  // No triggerPrefix — activates via semantic matching or model suggestion
+});
+```
+
+### Skill via SKILL.md file
+
+Create markdown files with YAML frontmatter in a directory:
+
+```
+.skills/
+  code-review/
+    SKILL.md
+  translate/
+    SKILL.md
+```
+
+**`.skills/code-review/SKILL.md`:**
+
+```markdown
+---
+name: code-review
+description: Reviews code for quality and bugs
+whenToUse: When user asks to review, audit, or check code quality
+triggerPrefix: /review
+aliases: [cr, audit]
+argNames: [file]
+allowedTools: [Read, Grep]
+priority: 8
+---
+
+You are in code review mode.
+Review $file for bugs, security issues, and performance.
+Skill directory: ${SKILL_DIR}
+```
+
+**Loading:**
+
+```typescript
+// Via config (auto-load in constructor)
+const agent = Agent.create({
+  apiKey: '...',
+  skills: { skillsDir: './.skills' },
+});
+
+// Or manually
+await agent.loadSkillsDir('./.skills');
+```
+
+### Conditional skill (path-activated)
+
+Skills with `paths` remain inactive until a matching file is touched.
+
+```typescript
+agent.addSkill({
+  name: 'ts-linter',
+  description: 'TypeScript linting rules',
+  instructions: 'Apply strict TypeScript linting...',
+  paths: ['src/**/*.ts', 'tests/**/*.ts'],
+  match: () => true,
+});
+
+// Activates when a file is touched
+agent.activateSkillsForPaths(['src/agent.ts']);
+```
+
+### Exclusive skill
+
+```typescript
+agent.addSkill({
+  name: 'focus-mode',
+  description: 'Deep focus on a single task',
+  instructions: 'Focus exclusively on the current task.',
+  triggerPrefix: '/focus',
+  exclusive: true, // blocks all other skills
+});
+```
+
+### Frontmatter reference (SKILL.md)
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | string | Unique skill name |
+| `description` | string | Short description |
+| `whenToUse` | string | Usage scenarios (for model discovery) |
+| `triggerPrefix` | string | Activation prefix (e.g. `/review`) |
+| `aliases` | string[] | Alternative names |
+| `argNames` | string[] | Argument names for substitution |
+| `allowedTools` | string[] | Tools the skill can use |
+| `model` | string | Model override |
+| `context` | `inline` \| `fork` | Execution mode |
+| `paths` | string[] | Globs for conditional activation |
+| `effort` | number | Computational effort hint (1-10) |
+| `exclusive` | boolean | Blocks other skills |
+| `priority` | number | Priority (higher wins) |
+| `modelInvocable` | boolean | Whether the model can invoke (default: true) |
+
+### Skills API
+
+```typescript
+agent.addSkill(skill)                          // register
+agent.removeSkill('name')                      // remove
+agent.listSkills()                             // list
+await agent.loadSkillsDir('./skills')          // load from directory
+agent.activateSkillsForPaths(['file.ts'])      // activate conditionals
+```
+
+### Matching hierarchy
+
+Skills are evaluated at 4 levels (most specific first):
+
+1. **Prefix** — `input.startsWith(triggerPrefix)` (score 1.0)
+2. **Alias** — `input.startsWith(/alias)` (score 0.95)
+3. **Custom** — `skill.match(input)` returns true (score 0.8)
+4. **Semantic** — cosine similarity > 0.7 with `description + whenToUse` (requires EmbeddingService)
+
+Maximum of 3 simultaneously active skills (configurable via `skills.maxActiveSkills`).
+
+## Memory
+
+Persistent file-based memory system inspired by Claude Code.
+
+```typescript
+// Save memory explicitly
+await agent.remember('User prefers dark mode', 'user');
+
+// Search relevant memories
+const memories = await agent.recall('What are the user preferences?');
+
+// Automatic extraction: after each turn, the agent extracts memories
+// from the conversation in the background (fire-and-forget)
+```
+
+Memories are `.md` files with YAML frontmatter in `.agentx/memory/` (configurable). Four types: `user`, `feedback`, `project`, `reference`.
+
+## Knowledge (RAG)
+
+```typescript
+await agent.ingestKnowledge({
+  id: 'docs-api',
+  content: apiDocs,
+  metadata: { source: 'api-docs.md' },
+});
+
+// The agent automatically searches knowledge when relevant
+await agent.chat('How do I authenticate with the API?');
+```
+
+## MCP (Model Context Protocol)
+
+Connect to any MCP server to extend agent capabilities with external tools, resources and prompts.
+
+### Basic connection
+
+```typescript
+await agent.connectMCP({
+  name: 'github',
+  transport: 'stdio',
+  command: 'npx',
+  args: ['-y', '@modelcontextprotocol/server-github'],
+});
+
+// Server tools are registered automatically (mcp__github__create_issue, etc.)
+await agent.chat('List my open PRs');
+await agent.disconnectMCP('github');
+```
+
+### Supported transports
+
+```typescript
+// Stdio — local subprocess (Node, Python, Rust MCP servers)
+await agent.connectMCP({
+  name: 'local-server',
+  transport: 'stdio',
+  command: 'npx',
+  args: ['-y', '@modelcontextprotocol/server-filesystem'],
+});
+
+// SSE — Server-Sent Events (long-lived connection)
+await agent.connectMCP({
+  name: 'remote-sse',
+  transport: 'sse',
+  url: 'https://mcp.example.com/sse',
+  headers: { 'Authorization': 'Bearer sk-...' },
+});
+
+// HTTP — Streamable HTTP (modern servers, bidirectional)
+await agent.connectMCP({
+  name: 'remote-http',
+  transport: 'http',
+  url: 'https://mcp.example.com/v1',
+  headers: { 'Authorization': 'Bearer sk-...' },
+});
+```
+
+### Automatic tool annotations
+
+MCP servers that declare `readOnlyHint` or `destructiveHint` in tools are automatically mapped to AgentTool flags:
+
+| MCP Annotation | AgentTool Flag | Effect |
+|---|---|---|
+| `readOnlyHint: true` | `isReadOnly: true` + `isConcurrencySafe: true` | Tools run in parallel, no warning |
+| `destructiveHint: true` | `isDestructive: true` | Model receives caution warning |
+
+### Server instructions
+
+If the MCP server returns `instructions` in the handshake, they are automatically injected into the model context — the agent follows the server's guidance.
+
+### MCP Prompts as Skills
+
+Prompts that the MCP server offers via `prompts/list` are automatically registered as skills. The model can invoke them via SkillTool:
+
+```typescript
+await agent.connectMCP({
+  name: 'docs',
+  transport: 'stdio',
+  command: 'npx',
+  args: ['my-docs-server'],
+});
+
+// If the server has a "summarize" prompt, it becomes a skill: mcp__docs__summarize
+// The model can call: Skill({ skill: "mcp__docs__summarize", args: "..." })
+```
+
+### Resources
+
+```typescript
+// List available resources from a server
+const resources = await agent.mcpAdapter.listResources('github');
+// [{ uri: 'repo://owner/project', name: 'Project', serverName: 'github' }]
+
+// Read resource content
+const content = await agent.mcpAdapter.readResource('github', 'repo://owner/project');
+```
+
+### Full configuration
+
+```typescript
+await agent.connectMCP({
+  name: 'my-server',
+  transport: 'stdio',           // 'stdio' | 'sse' | 'http'
+  command: 'npx',               // for stdio
+  args: ['-y', 'my-mcp-server'],
+  // url: 'https://...',        // for sse/http
+  // headers: { ... },          // for sse/http
+  timeout: 30_000,              // timeout per tool call (ms)
+  maxRetries: 3,                // reconnection attempts
+  healthCheckInterval: 60_000,  // periodic health check (ms)
+  isolateErrors: true,          // errors don't propagate (default: true)
+});
+```
+
+### Health monitoring
+
+```typescript
+const health = agent.getHealth();
+// {
+//   servers: [{
+//     name: 'github',
+//     status: 'connected',    // 'connected' | 'disconnected' | 'error' | 'reconnecting'
+//     toolCount: 15,
+//     uptime: 120000
+//   }]
+// }
+```
+
+### Deep JSON Schema
+
+MCP tools with complex schemas (nested objects, arrays, enums) are automatically converted to Zod — works with GitHub, Slack, and any server that uses rich schemas:
+
+```typescript
+// This works automatically — nested schema converted to Zod
+await agent.chat('Create a GitHub issue with labels bug and urgent');
+// LLM calls: mcp__github__create_issue({
+//   owner: "user", repo: "project",
+//   title: "...", labels: ["bug", "urgent"]
+// })
+```
+
+## Streaming Events
+
+```typescript
+for await (const event of agent.stream('Build a TODO app')) {
+  switch (event.type) {
+    case 'agent_start':      // Execution started
+    case 'skill_activated':  // Skill activated (event.skillName)
+    case 'text_delta':       // Text chunk (event.content)
+    case 'text_done':        // Full text complete
+    case 'tool_call_start':  // Tool called
+    case 'tool_call_end':    // Tool result
+    case 'turn_start':       // Loop iteration started
+    case 'turn_end':         // Loop iteration ended
+    case 'agent_end':        // Finished (event.usage, event.duration)
+    case 'error':            // Error (event.recoverable)
+    case 'warning':          // Warning
+    case 'compaction':       // Context compacted
+    case 'recovery':         // Automatic recovery
+    case 'model_fallback':   // Model fallback
+  }
+}
+```
+
+## Configuration
+
+```typescript
+const agent = Agent.create({
+  apiKey: 'sk-...',
+  baseUrl: 'https://api.openai.com/v1',   // optional — any OpenAI-compatible URL
+  model: 'gpt-4o',
+  systemPrompt: 'You are a helpful assistant.',
+
+  // Separate embedding provider (optional)
+  embedding: {
+    apiKey: 'sk-...',
+    baseUrl: 'https://api.openai.com/v1',
+    model: 'text-embedding-3-small',
+  },
+
+  // Skills
+  skills: {
+    skillsDir: './.skills',     // Auto-load skills from directory
+    maxActiveSkills: 3,         // Max simultaneous skills
+    modelDiscovery: true,       // List skills for model context
+  },
+
+  // Memory
+  memory: {
+    enabled: true,
+    memoryDir: '.agentx/memory/',
+    extractionEnabled: true,
+    samplingRate: 0.3,          // 30% chance per turn
+    extractionInterval: 10,     // Force every 10 turns
+  },
+
+  // Knowledge
+  knowledge: {
+    enabled: true,
+    chunkSize: 512,
+    topK: 5,
+    minScore: 0.3,
+  },
+
+  // Behavior
+  maxIterations: 10,
+  onToolError: 'continue',     // 'continue' | 'stop' | 'retry'
+
+  // Cost control
+  costPolicy: {
+    maxTokensPerExecution: 50_000,
+    onLimitReached: 'stop',
+  },
+
+  // Context
+  maxContextTokens: 128_000,
+  compactionThreshold: 0.8,
+
+  // Recovery
+  fallbackModel: 'anthropic/claude-haiku-4-5-20251001',
+  maxOutputTokens: 4096,
+  escalatedMaxOutputTokens: 16384,
+
+  // Observability
+  logLevel: 'info',
+});
+```
+
+## Pluggable Stores
+
+```typescript
+import { Agent } from 'agentx-sdk';
+
+// Custom conversation store (e.g. PostgreSQL)
+const agent = Agent.create({
+  apiKey: '...',
+  conversation: { store: myPostgresConversationStore },
+  knowledge: { store: myPineconeVectorStore },
+});
+```
+
+Interfaces: `ConversationStore`, `VectorStore` — implement to use any backend.
+
+## Stack
+
+| Layer | Technology |
+|-------|-----------|
+| Language | TypeScript 5.x |
+| Runtime | Node.js 22+ |
+| Validation | Zod 3.x |
+| Persistence | better-sqlite3 + SQLite |
+| Tools schema | zod-to-json-schema |
+| LLM | Any OpenAI-compatible API (native fetch) |
+
+**<= 4 direct dependencies.** Zero AI frameworks. No vendor lock-in.
+
+## License
+
+MIT
+
+---
+
+<details>
+<summary><h1>Portugues</h1></summary>
+
+# AgentX SDK
+
 Biblioteca TypeScript para construir agentes conversacionais com LLM. Streaming-first, tools, memory, knowledge/RAG, skills e MCP — tudo in-process, sem frameworks.
 
 ```bash
@@ -11,7 +601,11 @@ npm install agentx-sdk
 ```typescript
 import { Agent } from 'agentx-sdk';
 
-const agent = Agent.create({ apiKey: process.env.OPENROUTER_API_KEY! });
+// Funciona com qualquer API OpenAI-compatible (OpenRouter, OpenAI, Azure, Groq, etc.)
+const agent = Agent.create({
+  apiKey: process.env.LLM_API_KEY!,
+  // baseUrl: 'https://api.openai.com/v1',  // opcional — default: OpenRouter
+});
 
 // Chat simples
 const response = await agent.chat('Qual a capital da Franca?');
@@ -248,7 +842,7 @@ agent.addSkill({
 });
 ```
 
-### Frontmatter reference (SKILL.md)
+### Referencia de frontmatter (SKILL.md)
 
 | Campo | Tipo | Descricao |
 |-------|------|-----------|
@@ -267,7 +861,7 @@ agent.addSkill({
 | `priority` | number | Prioridade (maior vence) |
 | `modelInvocable` | boolean | Se o modelo pode invocar (default: true) |
 
-### Skills API
+### API de Skills
 
 ```typescript
 agent.addSkill(skill)                          // registrar
@@ -277,7 +871,7 @@ await agent.loadSkillsDir('./skills')          // carregar de diretorio
 agent.activateSkillsForPaths(['file.ts'])      // ativar condicionais
 ```
 
-### Matching hierarchy
+### Hierarquia de matching
 
 Skills sao avaliadas em 4 niveis (mais especifico primeiro):
 
@@ -303,7 +897,7 @@ const memories = await agent.recall('What are the user preferences?');
 // da conversa em background (fire-and-forget)
 ```
 
-Memorias sao arquivos `.md` com frontmatter YAML em `~/.agent/memory/` (configuravel). Quatro tipos: `user`, `feedback`, `project`, `reference`.
+Memorias sao arquivos `.md` com frontmatter YAML em `.agentx/memory/` (configuravel). Quatro tipos: `user`, `feedback`, `project`, `reference`.
 
 ## Knowledge (RAG)
 
@@ -348,7 +942,7 @@ await agent.connectMCP({
   args: ['-y', '@modelcontextprotocol/server-filesystem'],
 });
 
-// SSE — Server-Sent Events (long-lived connection)
+// SSE — Server-Sent Events (conexao persistente)
 await agent.connectMCP({
   name: 'remote-sse',
   transport: 'sse',
@@ -356,7 +950,7 @@ await agent.connectMCP({
   headers: { 'Authorization': 'Bearer sk-...' },
 });
 
-// HTTP — Streamable HTTP (servers modernos, bidirectional)
+// HTTP — Streamable HTTP (servers modernos, bidirecional)
 await agent.connectMCP({
   name: 'remote-http',
   transport: 'http',
@@ -365,16 +959,16 @@ await agent.connectMCP({
 });
 ```
 
-### Tool annotations automaticas
+### Anotacoes automaticas de tools
 
 MCP servers que declaram `readOnlyHint` ou `destructiveHint` nas tools sao mapeados automaticamente para os flags do AgentTool:
 
-| MCP Annotation | AgentTool Flag | Efeito |
+| Anotacao MCP | Flag AgentTool | Efeito |
 |---|---|---|
 | `readOnlyHint: true` | `isReadOnly: true` + `isConcurrencySafe: true` | Tools executam em paralelo, sem warning |
 | `destructiveHint: true` | `isDestructive: true` | Modelo recebe aviso de cautela |
 
-### Server instructions
+### Instrucoes do server
 
 Se o MCP server retorna `instructions` no handshake, elas sao injetadas automaticamente no contexto do modelo — o agente segue as orientacoes do server.
 
@@ -422,7 +1016,7 @@ await agent.connectMCP({
 });
 ```
 
-### Health monitoring
+### Monitoramento de saude
 
 ```typescript
 const health = agent.getHealth();
@@ -472,28 +1066,36 @@ for await (const event of agent.stream('Build a TODO app')) {
 }
 ```
 
-## Configuration
+## Configuracao
 
 ```typescript
 const agent = Agent.create({
   apiKey: 'sk-...',
-  model: 'anthropic/claude-sonnet-4-20250514',
+  baseUrl: 'https://api.openai.com/v1',   // optional — any OpenAI-compatible URL
+  model: 'gpt-4o',
   systemPrompt: 'You are a helpful assistant.',
 
+  // Separate embedding provider (optional)
+  embedding: {
+    apiKey: 'sk-...',
+    baseUrl: 'https://api.openai.com/v1',
+    model: 'text-embedding-3-small',
+  },
+
   // Skills
   skills: {
-    skillsDir: './.skills',     // Auto-load skills from directory
-    maxActiveSkills: 3,         // Max simultaneous skills
-    modelDiscovery: true,       // List skills for model context
+    skillsDir: './.skills',     // Auto-load de skills do diretorio
+    maxActiveSkills: 3,         // Max skills simultaneas
+    modelDiscovery: true,       // Listar skills no contexto do modelo
   },
 
   // Memory
   memory: {
     enabled: true,
-    memoryDir: '~/.agent/memory/',
+    memoryDir: '.agentx/memory/',
     extractionEnabled: true,
-    samplingRate: 0.3,          // 30% chance per turn
-    extractionInterval: 10,     // Force every 10 turns
+    samplingRate: 0.3,          // 30% de chance por turn
+    extractionInterval: 10,     // Forcar a cada 10 turns
   },
 
   // Knowledge
@@ -504,17 +1106,17 @@ const agent = Agent.create({
     minScore: 0.3,
   },
 
-  // Behavior
+  // Comportamento
   maxIterations: 10,
   onToolError: 'continue',     // 'continue' | 'stop' | 'retry'
 
-  // Cost control
+  // Controle de custo
   costPolicy: {
     maxTokensPerExecution: 50_000,
     onLimitReached: 'stop',
   },
 
-  // Context
+  // Contexto
   maxContextTokens: 128_000,
   compactionThreshold: 0.8,
 
@@ -523,7 +1125,7 @@ const agent = Agent.create({
   maxOutputTokens: 4096,
   escalatedMaxOutputTokens: 16384,
 
-  // Observability
+  // Observabilidade
   logLevel: 'info',
 });
 ```
@@ -552,10 +1154,12 @@ Interfaces: `ConversationStore`, `VectorStore` — implemente para usar qualquer
 | Validacao | Zod 3.x |
 | Persistencia | better-sqlite3 + SQLite |
 | Tools schema | zod-to-json-schema |
-| LLM | OpenRouter (fetch nativo) |
+| LLM | Qualquer API OpenAI-compatible (fetch nativo) |
 
-**<= 4 dependencias diretas.** Zero frameworks de IA.
+**<= 4 dependencias diretas.** Zero frameworks de IA. Sem vendor lock-in.
 
 ## License
 
 MIT
+
+</details>