codebot-ai 1.0.0

package/dist/context/repo-map.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRepoMap = buildRepoMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Build a lightweight repo map (~200-500 tokens) to give the model project awareness.
+ */
+function buildRepoMap(rootDir) {
+    const lines = ['Project structure:'];
+    const maxFiles = 50;
+    let fileCount = 0;
+    const skip = new Set([
+        'node_modules', '.git', 'dist', 'build', 'coverage',
+        '__pycache__', '.next', '.cache', '.codebot', '.venv', 'venv',
+    ]);
+    const walk = (dir, prefix, depth) => {
+        if (depth > 4 || fileCount > maxFiles)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of entries) {
+            if (skip.has(entry.name) || (entry.name.startsWith('.') && entry.name !== '.env.example'))
+                continue;
+            if (fileCount > maxFiles)
+                break;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                lines.push(`${prefix}${entry.name}/`);
+                walk(fullPath, prefix + '  ', depth + 1);
+            }
+            else {
+                fileCount++;
+                lines.push(`${prefix}${entry.name}`);
+            }
+        }
+    };
+    walk(rootDir, '  ', 0);
+    // Add key file info
+    const pkgPath = path.join(rootDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            lines.push(`\npackage.json: ${pkg.name || 'unnamed'} v${pkg.version || '0.0.0'}`);
+            if (pkg.scripts) {
+                lines.push(`  scripts: ${Object.keys(pkg.scripts).join(', ')}`);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=repo-map.js.map

package/dist/history.d.ts

@@ -0,0 +1,27 @@
+import { Message } from './types';
+export interface SessionMeta {
+    id: string;
+    model: string;
+    created: string;
+    updated: string;
+    messageCount: number;
+    preview: string;
+}
+export declare class SessionManager {
+    private sessionId;
+    private filePath;
+    private model;
+    constructor(model: string, sessionId?: string);
+    getId(): string;
+    /** Append a message to the session file */
+    save(message: Message): void;
+    /** Save all messages (overwrite) */
+    saveAll(messages: Message[]): void;
+    /** Load messages from a session file */
+    load(): Message[];
+    /** List recent sessions */
+    static list(limit?: number): SessionMeta[];
+    /** Get the most recent session ID */
+    static latest(): string | undefined;
+}
+//# sourceMappingURL=history.d.ts.map

package/dist/history.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const SESSIONS_DIR = path.join(os.homedir(), '.codebot', 'sessions');
+class SessionManager {
+    sessionId;
+    filePath;
+    model;
+    constructor(model, sessionId) {
+        this.model = model;
+        this.sessionId = sessionId || crypto.randomUUID();
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        this.filePath = path.join(SESSIONS_DIR, `${this.sessionId}.jsonl`);
+    }
+    getId() {
+        return this.sessionId;
+    }
+    /** Append a message to the session file */
+    save(message) {
+        const line = JSON.stringify({
+            ...message,
+            _ts: new Date().toISOString(),
+            _model: this.model,
+        });
+        fs.appendFileSync(this.filePath, line + '\n');
+    }
+    /** Save all messages (overwrite) */
+    saveAll(messages) {
+        const lines = messages.map(m => JSON.stringify({ ...m, _ts: new Date().toISOString(), _model: this.model }));
+        fs.writeFileSync(this.filePath, lines.join('\n') + '\n');
+    }
+    /** Load messages from a session file */
+    load() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        const content = fs.readFileSync(this.filePath, 'utf-8').trim();
+        if (!content)
+            return [];
+        return content.split('\n').map(line => {
+            const obj = JSON.parse(line);
+            delete obj._ts;
+            delete obj._model;
+            return obj;
+        });
+    }
+    /** List recent sessions */
+    static list(limit = 10) {
+        if (!fs.existsSync(SESSIONS_DIR))
+            return [];
+        const files = fs.readdirSync(SESSIONS_DIR)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => {
+            const fullPath = path.join(SESSIONS_DIR, f);
+            const stat = fs.statSync(fullPath);
+            return { name: f, mtime: stat.mtime };
+        })
+            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+            .slice(0, limit);
+        return files.map(f => {
+            const id = f.name.replace('.jsonl', '');
+            const fullPath = path.join(SESSIONS_DIR, f.name);
+            const content = fs.readFileSync(fullPath, 'utf-8').trim();
+            const lines = content ? content.split('\n') : [];
+            let model = '';
+            let created = '';
+            let updated = '';
+            let preview = '';
+            if (lines.length > 0) {
+                try {
+                    const first = JSON.parse(lines[0]);
+                    created = first._ts || '';
+                    model = first._model || '';
+                }
+                catch { /* skip */ }
+                try {
+                    const last = JSON.parse(lines[lines.length - 1]);
+                    updated = last._ts || '';
+                }
+                catch { /* skip */ }
+                // Find first user message for preview
+                for (const line of lines) {
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.role === 'user') {
+                            preview = msg.content.substring(0, 80);
+                            break;
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            return {
+                id,
+                model,
+                created,
+                updated,
+                messageCount: lines.length,
+                preview,
+            };
+        });
+    }
+    /** Get the most recent session ID */
+    static latest() {
+        const sessions = SessionManager.list(1);
+        return sessions[0]?.id;
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=history.js.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { Agent } from './agent';
+export { OpenAIProvider } from './providers/openai';
+export { AnthropicProvider } from './providers/anthropic';
+export { ToolRegistry } from './tools';
+export { ContextManager } from './context/manager';
+export { buildRepoMap } from './context/repo-map';
+export { SessionManager } from './history';
+export { MemoryManager } from './memory';
+export { parseToolCalls } from './parser';
+export { MODEL_REGISTRY, PROVIDER_DEFAULTS, getModelInfo, detectProvider } from './providers/registry';
+export type { ModelInfo } from './providers/registry';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProvider = exports.getModelInfo = exports.PROVIDER_DEFAULTS = exports.MODEL_REGISTRY = exports.parseToolCalls = exports.MemoryManager = exports.SessionManager = exports.buildRepoMap = exports.ContextManager = exports.ToolRegistry = exports.AnthropicProvider = exports.OpenAIProvider = exports.Agent = void 0;
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+var openai_1 = require("./providers/openai");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_1.OpenAIProvider; } });
+var anthropic_1 = require("./providers/anthropic");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_1.AnthropicProvider; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return tools_1.ToolRegistry; } });
+var manager_1 = require("./context/manager");
+Object.defineProperty(exports, "ContextManager", { enumerable: true, get: function () { return manager_1.ContextManager; } });
+var repo_map_1 = require("./context/repo-map");
+Object.defineProperty(exports, "buildRepoMap", { enumerable: true, get: function () { return repo_map_1.buildRepoMap; } });
+var history_1 = require("./history");
+Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return history_1.SessionManager; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "MemoryManager", { enumerable: true, get: function () { return memory_1.MemoryManager; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseToolCalls", { enumerable: true, get: function () { return parser_1.parseToolCalls; } });
+var registry_1 = require("./providers/registry");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return registry_1.MODEL_REGISTRY; } });
+Object.defineProperty(exports, "PROVIDER_DEFAULTS", { enumerable: true, get: function () { return registry_1.PROVIDER_DEFAULTS; } });
+Object.defineProperty(exports, "getModelInfo", { enumerable: true, get: function () { return registry_1.getModelInfo; } });
+Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return registry_1.detectProvider; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/memory.d.ts

@@ -0,0 +1,39 @@
+export interface MemoryEntry {
+    key: string;
+    value: string;
+    source: 'user' | 'agent';
+    created: string;
+}
+/**
+ * Persistent memory system for CodeBot.
+ * Stores project-level and global notes that survive across sessions.
+ * Memory is injected into the system prompt so the model always has context.
+ */
+export declare class MemoryManager {
+    private projectDir;
+    private globalDir;
+    constructor(projectRoot?: string);
+    /** Read the global memory file */
+    readGlobal(): string;
+    /** Read project-level memory */
+    readProject(): string;
+    /** Write to global memory */
+    writeGlobal(content: string): void;
+    /** Write to project memory */
+    writeProject(content: string): void;
+    /** Append an entry to global memory */
+    appendGlobal(entry: string): void;
+    /** Append an entry to project memory */
+    appendProject(entry: string): void;
+    /** Read all memory files from a directory */
+    private readDir;
+    /** Get all memory content formatted for system prompt injection */
+    getContextBlock(): string;
+    /** List all memory files */
+    list(): Array<{
+        scope: 'global' | 'project';
+        file: string;
+        size: number;
+    }>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/memory.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MEMORY_DIR = path.join(os.homedir(), '.codebot', 'memory');
+const GLOBAL_MEMORY = path.join(MEMORY_DIR, 'MEMORY.md');
+/**
+ * Persistent memory system for CodeBot.
+ * Stores project-level and global notes that survive across sessions.
+ * Memory is injected into the system prompt so the model always has context.
+ */
+class MemoryManager {
+    projectDir;
+    globalDir;
+    constructor(projectRoot) {
+        this.projectDir = projectRoot
+            ? path.join(projectRoot, '.codebot', 'memory')
+            : '';
+        this.globalDir = MEMORY_DIR;
+        fs.mkdirSync(this.globalDir, { recursive: true });
+        if (this.projectDir) {
+            fs.mkdirSync(this.projectDir, { recursive: true });
+        }
+    }
+    /** Read the global memory file */
+    readGlobal() {
+        if (fs.existsSync(GLOBAL_MEMORY)) {
+            return fs.readFileSync(GLOBAL_MEMORY, 'utf-8');
+        }
+        return '';
+    }
+    /** Read project-level memory */
+    readProject() {
+        if (!this.projectDir)
+            return '';
+        const memFile = path.join(this.projectDir, 'MEMORY.md');
+        if (fs.existsSync(memFile)) {
+            return fs.readFileSync(memFile, 'utf-8');
+        }
+        return '';
+    }
+    /** Write to global memory */
+    writeGlobal(content) {
+        fs.writeFileSync(GLOBAL_MEMORY, content);
+    }
+    /** Write to project memory */
+    writeProject(content) {
+        if (!this.projectDir)
+            return;
+        const memFile = path.join(this.projectDir, 'MEMORY.md');
+        fs.writeFileSync(memFile, content);
+    }
+    /** Append an entry to global memory */
+    appendGlobal(entry) {
+        const current = this.readGlobal();
+        const updated = current ? `${current.trimEnd()}\n\n${entry}` : entry;
+        this.writeGlobal(updated);
+    }
+    /** Append an entry to project memory */
+    appendProject(entry) {
+        if (!this.projectDir)
+            return;
+        const current = this.readProject();
+        const updated = current ? `${current.trimEnd()}\n\n${entry}` : entry;
+        this.writeProject(updated);
+    }
+    /** Read all memory files from a directory */
+    readDir(dir) {
+        const files = {};
+        if (!fs.existsSync(dir))
+            return files;
+        for (const name of fs.readdirSync(dir)) {
+            if (!name.endsWith('.md'))
+                continue;
+            files[name] = fs.readFileSync(path.join(dir, name), 'utf-8');
+        }
+        return files;
+    }
+    /** Get all memory content formatted for system prompt injection */
+    getContextBlock() {
+        const parts = [];
+        const global = this.readGlobal();
+        if (global.trim()) {
+            parts.push(`## Global Memory\n${global.trim()}`);
+        }
+        // Read additional global topic files
+        const globalFiles = this.readDir(this.globalDir);
+        for (const [name, content] of Object.entries(globalFiles)) {
+            if (name === 'MEMORY.md' || !content.trim())
+                continue;
+            parts.push(`## ${name.replace('.md', '')}\n${content.trim()}`);
+        }
+        const project = this.readProject();
+        if (project.trim()) {
+            parts.push(`## Project Memory\n${project.trim()}`);
+        }
+        // Read additional project topic files
+        if (this.projectDir) {
+            const projFiles = this.readDir(this.projectDir);
+            for (const [name, content] of Object.entries(projFiles)) {
+                if (name === 'MEMORY.md' || !content.trim())
+                    continue;
+                parts.push(`## Project: ${name.replace('.md', '')}\n${content.trim()}`);
+            }
+        }
+        if (parts.length === 0)
+            return '';
+        return `\n\n--- Persistent Memory ---\n${parts.join('\n\n')}`;
+    }
+    /** List all memory files */
+    list() {
+        const result = [];
+        if (fs.existsSync(this.globalDir)) {
+            for (const name of fs.readdirSync(this.globalDir)) {
+                if (!name.endsWith('.md'))
+                    continue;
+                const stat = fs.statSync(path.join(this.globalDir, name));
+                result.push({ scope: 'global', file: name, size: stat.size });
+            }
+        }
+        if (this.projectDir && fs.existsSync(this.projectDir)) {
+            for (const name of fs.readdirSync(this.projectDir)) {
+                if (!name.endsWith('.md'))
+                    continue;
+                const stat = fs.statSync(path.join(this.projectDir, name));
+                result.push({ scope: 'project', file: name, size: stat.size });
+            }
+        }
+        return result;
+    }
+}
+exports.MemoryManager = MemoryManager;
+//# sourceMappingURL=memory.js.map

package/dist/parser.d.ts

@@ -0,0 +1,8 @@
+import { ToolCall } from './types';
+/**
+ * Parse tool calls from LLM text output.
+ * Used as fallback when models don't support native tool calling.
+ * Tries multiple formats: XML tags, code blocks, function notation.
+ */
+export declare function parseToolCalls(text: string): ToolCall[];
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToolCalls = parseToolCalls;
+const KNOWN_TOOLS = ['read_file', 'write_file', 'edit_file', 'execute', 'glob', 'grep', 'git', 'think'];
+/**
+ * Parse tool calls from LLM text output.
+ * Used as fallback when models don't support native tool calling.
+ * Tries multiple formats: XML tags, code blocks, function notation.
+ */
+function parseToolCalls(text) {
+    const calls = [];
+    let id = 0;
+    // Pattern 1: <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+    const xmlPattern = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+    let match;
+    while ((match = xmlPattern.exec(text)) !== null) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (parsed.name) {
+                calls.push({
+                    id: `call_${id++}`,
+                    type: 'function',
+                    function: {
+                        name: parsed.name,
+                        arguments: JSON.stringify(parsed.arguments || parsed.params || {}),
+                    },
+                });
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    if (calls.length > 0)
+        return calls;
+    // Pattern 2: ```tool_call\n{...}\n``` or ```json\n{...}\n```
+    const codeBlockPattern = /```(?:tool_call|json)?\s*\n\s*(\{[\s\S]*?\})\s*\n\s*```/g;
+    while ((match = codeBlockPattern.exec(text)) !== null) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (parsed.name && (parsed.arguments || parsed.params)) {
+                calls.push({
+                    id: `call_${id++}`,
+                    type: 'function',
+                    function: {
+                        name: parsed.name,
+                        arguments: JSON.stringify(parsed.arguments || parsed.params || {}),
+                    },
+                });
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    if (calls.length > 0)
+        return calls;
+    // Pattern 3: tool_name({"arg": "value"})
+    const toolNames = KNOWN_TOOLS.join('|');
+    const funcPattern = new RegExp(`\\b(${toolNames})\\s*\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`, 'g');
+    while ((match = funcPattern.exec(text)) !== null) {
+        try {
+            const args = JSON.parse(match[2]);
+            calls.push({
+                id: `call_${id++}`,
+                type: 'function',
+                function: {
+                    name: match[1],
+                    arguments: JSON.stringify(args),
+                },
+            });
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return calls;
+}
+//# sourceMappingURL=parser.js.map

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,9 @@
+import { LLMProvider, Message, ToolSchema, StreamEvent, ProviderConfig } from '../types';
+export declare class AnthropicProvider implements LLMProvider {
+    name: string;
+    private config;
+    constructor(config: ProviderConfig);
+    chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
+    private convertMessages;
+}
+//# sourceMappingURL=anthropic.d.ts.map