@syrin/cli 1.3.0

package/dist/runtime/dev/stack-trace.js

@@ -0,0 +1,286 @@
+/**
+ * Stack trace generation from events.
+ * Generates human-readable stack traces from event sequences to aid debugging.
+ */
+import { ToolExecutionEventType, TransportEventType, ValidationEventType, LLMProposalEventType, DiagnosticEventType, SessionLifecycleEventType, } from '../../events/event-type.js';
+/**
+ * Generate a human-readable description for an event.
+ */
+function describeEvent(event) {
+    const { event_type, payload } = event;
+    switch (event_type) {
+        case SessionLifecycleEventType.SESSION_STARTED:
+            return 'Session started';
+        case SessionLifecycleEventType.SESSION_COMPLETED:
+            return 'Session completed successfully';
+        case SessionLifecycleEventType.SESSION_HALTED:
+            return 'Session halted';
+        case LLMProposalEventType.LLM_PROPOSED_TOOL_CALL: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            return `LLM proposed tool call: ${toolName}`;
+        }
+        case LLMProposalEventType.LLM_FINAL_RESPONSE_GENERATED:
+            return 'LLM generated final response';
+        case ValidationEventType.TOOL_CALL_VALIDATION_STARTED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            return `Validating tool call: ${toolName}`;
+        }
+        case ValidationEventType.TOOL_CALL_VALIDATION_PASSED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            return `Tool call validation passed: ${toolName}`;
+        }
+        case ValidationEventType.TOOL_CALL_VALIDATION_FAILED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            const errorMsg = p.error?.message || 'Unknown validation error';
+            return `Tool call validation failed: ${toolName} - ${errorMsg}`;
+        }
+        case ToolExecutionEventType.TOOL_EXECUTION_STARTED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            return `Tool execution started: ${toolName}`;
+        }
+        case ToolExecutionEventType.TOOL_EXECUTION_COMPLETED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            const duration = p.duration_ms ? `${p.duration_ms}ms` : 'unknown';
+            return `Tool execution completed: ${toolName} (${duration})`;
+        }
+        case ToolExecutionEventType.TOOL_EXECUTION_FAILED: {
+            const p = payload;
+            const toolName = p.tool_name || 'unknown';
+            const errorMsg = p.error?.message || 'Unknown error';
+            return `Tool execution failed: ${toolName} - ${errorMsg}`;
+        }
+        case TransportEventType.TRANSPORT_INITIALIZED: {
+            const p = payload;
+            const transport = p.transport_type || 'unknown';
+            const endpoint = p.endpoint || p.command || 'unknown';
+            return `Transport initialized: ${transport} (${endpoint})`;
+        }
+        case TransportEventType.TRANSPORT_MESSAGE_SENT: {
+            const p = payload;
+            const msgType = p.message_type || 'unknown';
+            const size = p.size_bytes ? `${p.size_bytes} bytes` : 'unknown size';
+            return `Transport message sent: ${msgType} (${size})`;
+        }
+        case TransportEventType.TRANSPORT_MESSAGE_RECEIVED: {
+            const p = payload;
+            const msgType = p.message_type || 'unknown';
+            const size = p.size_bytes ? `${p.size_bytes} bytes` : 'unknown size';
+            return `Transport message received: ${msgType} (${size})`;
+        }
+        case TransportEventType.TRANSPORT_ERROR: {
+            const p = payload;
+            const errorMsg = p.error_message || 'Unknown transport error';
+            return `Transport error: ${errorMsg}`;
+        }
+        case DiagnosticEventType.RUNTIME_ERROR: {
+            const p = payload;
+            const errorMsg = p.error_message || 'Unknown runtime error';
+            return `Runtime error: ${errorMsg}`;
+        }
+        default:
+            return `${event_type}`;
+    }
+}
+/**
+ * Extract context from an event payload.
+ */
+function extractContext(event) {
+    const { event_type, payload } = event;
+    const context = {};
+    switch (event_type) {
+        case ToolExecutionEventType.TOOL_EXECUTION_STARTED:
+        case ToolExecutionEventType.TOOL_EXECUTION_COMPLETED:
+        case ToolExecutionEventType.TOOL_EXECUTION_FAILED: {
+            const p = payload;
+            if (p.tool_name)
+                context.tool_name = p.tool_name;
+            if (p.execution_id)
+                context.execution_id = p.execution_id;
+            if (p.arguments)
+                context.arguments = p.arguments;
+            if (p.error)
+                context.error = p.error;
+            if (p.result)
+                context.result = p.result;
+            if (p.duration_ms !== undefined)
+                context.duration_ms = p.duration_ms;
+            break;
+        }
+        case TransportEventType.TRANSPORT_INITIALIZED:
+        case TransportEventType.TRANSPORT_MESSAGE_SENT:
+        case TransportEventType.TRANSPORT_MESSAGE_RECEIVED:
+        case TransportEventType.TRANSPORT_ERROR: {
+            const p = payload;
+            Object.assign(context, p);
+            break;
+        }
+        case ValidationEventType.TOOL_CALL_VALIDATION_FAILED: {
+            const p = payload;
+            if (p.tool_name)
+                context.tool_name = p.tool_name;
+            if (p.error)
+                context.error = p.error;
+            break;
+        }
+    }
+    return Object.keys(context).length > 0 ? context : undefined;
+}
+/**
+ * Determine if an event represents an error.
+ */
+function isErrorEvent(event) {
+    return (event.event_type === ToolExecutionEventType.TOOL_EXECUTION_FAILED ||
+        event.event_type === TransportEventType.TRANSPORT_ERROR ||
+        event.event_type === ValidationEventType.TOOL_CALL_VALIDATION_FAILED ||
+        event.event_type === DiagnosticEventType.RUNTIME_ERROR ||
+        event.event_type === SessionLifecycleEventType.SESSION_HALTED);
+}
+/**
+ * Determine if an event is critical for understanding execution flow.
+ */
+function isCriticalEvent(event) {
+    return (isErrorEvent(event) ||
+        event.event_type === SessionLifecycleEventType.SESSION_STARTED ||
+        event.event_type === SessionLifecycleEventType.SESSION_COMPLETED ||
+        event.event_type === SessionLifecycleEventType.SESSION_HALTED ||
+        event.event_type === ToolExecutionEventType.TOOL_EXECUTION_STARTED ||
+        event.event_type === ToolExecutionEventType.TOOL_EXECUTION_COMPLETED ||
+        event.event_type === ToolExecutionEventType.TOOL_EXECUTION_FAILED ||
+        event.event_type === ValidationEventType.TOOL_CALL_VALIDATION_FAILED ||
+        event.event_type === TransportEventType.TRANSPORT_ERROR ||
+        event.event_type === DiagnosticEventType.RUNTIME_ERROR);
+}
+/**
+ * Generate a stack trace from events for a given session.
+ *
+ * @param eventStore - Event store to query
+ * @param sessionId - Session ID to generate trace for
+ * @param options - Stack trace generation options
+ * @returns Stack trace
+ */
+export async function generateStackTrace(eventStore, sessionId, options = {}) {
+    const { includeAll = false, maxEntries, eventTypes, executionId, includeContext = true, } = options;
+    // Load events for the session
+    const events = await Promise.resolve(eventStore.load(sessionId));
+    const totalEvents = events.length;
+    // Filter events
+    let filteredEvents = events;
+    // Filter by event types if specified
+    if (eventTypes && eventTypes.length > 0) {
+        filteredEvents = filteredEvents.filter(e => eventTypes.includes(e.event_type));
+    }
+    // Filter by execution ID if specified
+    if (executionId) {
+        filteredEvents = filteredEvents.filter(e => {
+            const payload = e.payload;
+            return payload.execution_id === executionId;
+        });
+    }
+    // Filter to critical/error events if not including all
+    if (!includeAll) {
+        filteredEvents = filteredEvents.filter(e => isCriticalEvent(e));
+    }
+    // Sort by sequence number
+    filteredEvents.sort((a, b) => a.sequence - b.sequence);
+    // Limit entries if specified
+    if (maxEntries && filteredEvents.length > maxEntries) {
+        filteredEvents = filteredEvents.slice(-maxEntries);
+    }
+    // Convert to stack trace entries
+    const entries = filteredEvents.map(event => ({
+        eventId: event.event_id,
+        eventType: event.event_type,
+        timestamp: event.timestamp,
+        sequence: event.sequence,
+        description: describeEvent(event),
+        context: includeContext ? extractContext(event) : undefined,
+        isError: isErrorEvent(event),
+        isCritical: isCriticalEvent(event),
+    }));
+    // Count errors
+    const errorCount = entries.filter(e => e.isError).length;
+    const firstError = entries.find(e => e.isError);
+    // Generate summary
+    let summary = `Session ${sessionId}: ${totalEvents} total events`;
+    if (errorCount > 0) {
+        summary += `, ${errorCount} error(s)`;
+    }
+    if (filteredEvents.length < totalEvents) {
+        summary += `, ${filteredEvents.length} shown`;
+    }
+    return {
+        sessionId,
+        entries,
+        totalEvents,
+        errorCount,
+        firstError,
+        summary,
+    };
+}
+/**
+ * Format a stack trace as a human-readable string.
+ *
+ * @param stackTrace - Stack trace to format
+ * @returns Formatted string
+ */
+export function formatStackTrace(stackTrace) {
+    const lines = [];
+    lines.push(`\n${'='.repeat(80)}`);
+    lines.push(`STACK TRACE: ${stackTrace.summary}`);
+    lines.push(`${'='.repeat(80)}\n`);
+    if (stackTrace.firstError) {
+        lines.push(`⚠️  First Error: ${stackTrace.firstError.description}`);
+        if (stackTrace.firstError.context?.error) {
+            const error = stackTrace.firstError.context.error;
+            if (error?.message) {
+                lines.push(`   Message: ${error.message}`);
+            }
+            if (error?.code) {
+                lines.push(`   Code: ${error.code}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push('Event Sequence:');
+    lines.push('');
+    stackTrace.entries.forEach((entry, index) => {
+        const prefix = entry.isError ? '❌' : entry.isCritical ? '🔍' : '  ';
+        const seq = String(entry.sequence).padStart(4, '0');
+        // Parse timestamp safely
+        let time = entry.timestamp;
+        try {
+            const timestampParts = entry.timestamp.split('T');
+            if (timestampParts.length > 1) {
+                const timePart = timestampParts[1];
+                if (timePart) {
+                    const timeParts = timePart.split('.');
+                    time = timeParts[0] || entry.timestamp;
+                }
+            }
+        }
+        catch {
+            // Fallback to original timestamp if parsing fails
+            time = entry.timestamp;
+        }
+        lines.push(`${prefix} [${seq}] ${time} - ${entry.description}`);
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            const contextStr = JSON.stringify(entry.context, null, 2)
+                .split('\n')
+                .map(line => `    ${line}`)
+                .join('\n');
+            lines.push(contextStr);
+        }
+        if (index < stackTrace.entries.length - 1) {
+            lines.push('');
+        }
+    });
+    lines.push(`\n${'='.repeat(80)}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=stack-trace.js.map

package/dist/runtime/dev/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Dev Mode type definitions.
+ */
+import type { SyrinConfig } from '../../config/types.js';
+import type { LLMProvider } from '../../runtime/llm/provider.js';
+import type { MCPClientManager } from '../../runtime/mcp/client/manager.js';
+import type { EventEmitter } from '../../events/emitter.js';
+import type { LLMMessage } from '../../runtime/llm/types.js';
+/**
+ * Dev Mode session configuration.
+ */
+export interface DevSessionConfig {
+    /** Syrin configuration */
+    config: SyrinConfig;
+    /** LLM provider */
+    llmProvider: LLMProvider;
+    /** MCP client manager */
+    mcpClientManager: MCPClientManager;
+    /** Event emitter */
+    eventEmitter: EventEmitter;
+    /** Execution mode (true = execute, false = preview) */
+    executionMode: boolean;
+    /** Project root directory */
+    projectRoot: string;
+}
+/**
+ * Tool call information.
+ */
+export interface ToolCallInfo {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    result?: unknown;
+    /** Reference ID for large data stored externally */
+    resultReference?: string;
+    timestamp: Date;
+    duration?: number;
+}
+/**
+ * Dev Mode session state.
+ */
+export interface DevSessionState {
+    /** Conversation history */
+    conversationHistory: LLMMessage[];
+    /** Tool calls made during session */
+    toolCalls: ToolCallInfo[];
+    /** Total tool calls count */
+    totalToolCalls: number;
+    /** Total LLM calls count */
+    totalLLMCalls: number;
+    /** Session start time */
+    startTime: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/dev/types.js

@@ -0,0 +1,5 @@
+/**
+ * Dev Mode type definitions.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/llm/claude.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Claude (Anthropic) LLM provider implementation.
+ */
+import type { LLMProvider } from './provider.js';
+import type { LLMRequest, LLMResponse } from './types.js';
+import type { APIKey, ModelName } from '../../types/ids.js';
+/**
+ * Claude provider implementation.
+ */
+export declare class ClaudeProvider implements LLMProvider {
+    private client;
+    private modelName;
+    constructor(apiKey: string, modelName: string);
+    getName(): string;
+    getModelName(): string;
+    supportsToolCalls(): boolean;
+    chat(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * Create Claude provider from config.
+     * @param apiKeyEnvVar - Environment variable name for API key
+     * @param modelNameEnvVar - Environment variable name for model name
+     * @param projectRoot - Project root directory
+     * @returns Claude provider instance
+     */
+    static fromConfig(apiKeyEnvVar: APIKey | string, modelNameEnvVar: ModelName | string, projectRoot?: string): ClaudeProvider;
+}
+//# sourceMappingURL=claude.d.ts.map

package/dist/runtime/llm/claude.js

@@ -0,0 +1,150 @@
+/**
+ * Claude (Anthropic) LLM provider implementation.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { checkEnvVar } from '../../config/env-checker.js';
+import { ConfigurationError } from '../../utils/errors.js';
+/**
+ * Claude provider implementation.
+ */
+export class ClaudeProvider {
+    client;
+    modelName;
+    constructor(apiKey, modelName) {
+        if (!apiKey) {
+            throw new ConfigurationError('Claude API key is required');
+        }
+        if (!modelName) {
+            throw new ConfigurationError('Claude model name is required');
+        }
+        this.client = new Anthropic({
+            apiKey,
+        });
+        this.modelName = modelName;
+    }
+    getName() {
+        return 'Claude';
+    }
+    getModelName() {
+        return this.modelName;
+    }
+    supportsToolCalls() {
+        return true;
+    }
+    async chat(request) {
+        try {
+            // Convert tools to Claude format
+            // Claude requires input_schema to have a 'type' field set to 'object'
+            const tools = request.tools?.map(tool => {
+                const inputSchema = { ...tool.inputSchema };
+                // Ensure the schema has a 'type' field set to 'object'
+                const schemaWithType = {
+                    ...inputSchema,
+                    type: 'object',
+                };
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    input_schema: schemaWithType,
+                };
+            });
+            // Convert messages to Claude format
+            const messages = request.messages
+                .filter(msg => msg.role !== 'system') // System messages handled separately
+                .map(msg => ({
+                role: msg.role,
+                content: msg.content,
+            }));
+            // Extract system prompt
+            const systemPrompt = request.systemPrompt ||
+                request.messages.find(msg => msg.role === 'system')?.content ||
+                '';
+            // Build the request parameters
+            const requestParams = {
+                model: this.modelName,
+                max_tokens: request.maxTokens ?? 4096,
+                temperature: request.temperature ?? 0.7,
+                messages,
+            };
+            if (systemPrompt) {
+                requestParams.system = systemPrompt;
+            }
+            if (tools && tools.length > 0) {
+                // Cast tools to the expected type - the SDK will validate
+                requestParams.tools = tools;
+            }
+            const response = await this.client.messages.create(requestParams);
+            // Type guard: check if it's a Message (not a Stream)
+            if (!('content' in response)) {
+                throw new Error('Unexpected stream response from Claude API');
+            }
+            // Now TypeScript knows it's a Message
+            const message = response;
+            // Extract content from response
+            const contentBlocks = message.content.filter(block => block.type === 'text');
+            const content = contentBlocks
+                .map(block => (block.type === 'text' ? block.text : ''))
+                .join('\n');
+            // Extract tool use blocks
+            const toolCalls = [];
+            const toolUseBlocks = message.content.filter(block => block.type === 'tool_use');
+            for (const block of toolUseBlocks) {
+                if (block.type === 'tool_use' && block.id && block.name) {
+                    toolCalls.push({
+                        id: block.id,
+                        name: block.name,
+                        arguments: block.input || {},
+                    });
+                }
+            }
+            const finishReason = message.stop_reason === 'tool_use'
+                ? 'tool_calls'
+                : message.stop_reason === 'end_turn'
+                    ? 'stop'
+                    : message.stop_reason === 'max_tokens'
+                        ? 'length'
+                        : 'stop';
+            return {
+                content,
+                finishReason,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                usage: message.usage
+                    ? {
+                        promptTokens: message.usage.input_tokens,
+                        completionTokens: message.usage.output_tokens,
+                        totalTokens: message.usage.input_tokens + message.usage.output_tokens,
+                    }
+                    : undefined,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Claude API error: ${error.message}`);
+            }
+            throw new Error('Unknown error from Claude API');
+        }
+    }
+    /**
+     * Create Claude provider from config.
+     * @param apiKeyEnvVar - Environment variable name for API key
+     * @param modelNameEnvVar - Environment variable name for model name
+     * @param projectRoot - Project root directory
+     * @returns Claude provider instance
+     */
+    static fromConfig(apiKeyEnvVar, modelNameEnvVar, projectRoot = process.cwd()) {
+        // Check API key
+        const apiKeyCheck = checkEnvVar(apiKeyEnvVar, projectRoot);
+        if (!apiKeyCheck.isSet || !apiKeyCheck.value) {
+            throw new ConfigurationError(apiKeyCheck.errorMessage ||
+                `Claude API key (${apiKeyEnvVar}) is not set`);
+        }
+        // Check model name
+        const modelNameCheck = checkEnvVar(modelNameEnvVar, projectRoot);
+        if (!modelNameCheck.isSet || !modelNameCheck.value) {
+            throw new ConfigurationError(modelNameCheck.errorMessage ||
+                `Claude model name (${modelNameEnvVar}) is not set`);
+        }
+        return new ClaudeProvider(apiKeyCheck.value, modelNameCheck.value);
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/runtime/llm/factory.d.ts

@@ -0,0 +1,30 @@
+/**
+ * LLM provider factory.
+ * Creates LLM provider instances from configuration.
+ */
+import type { SyrinConfig } from '../../config/types.js';
+import type { LLMProvider } from './provider.js';
+/**
+ * Create an LLM provider from configuration.
+ * @param providerName - Name of the provider (e.g., "openai", "claude", "ollama")
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns LLM provider instance
+ */
+export declare function createLLMProvider(providerName: string, config: SyrinConfig, projectRoot?: string): LLMProvider;
+/**
+ * Get the default LLM provider from configuration.
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns Default LLM provider instance
+ */
+export declare function getDefaultLLMProvider(config: SyrinConfig, projectRoot?: string): LLMProvider;
+/**
+ * Get LLM provider by name or use default.
+ * @param providerName - Optional provider name (e.g., "openai", "claude")
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns LLM provider instance
+ */
+export declare function getLLMProvider(providerName: string | undefined, config: SyrinConfig, projectRoot?: string): LLMProvider;
+//# sourceMappingURL=factory.d.ts.map

package/dist/runtime/llm/factory.js

@@ -0,0 +1,78 @@
+/**
+ * LLM provider factory.
+ * Creates LLM provider instances from configuration.
+ */
+import { OpenAIProvider } from './openai.js';
+import { ClaudeProvider } from './claude.js';
+import { OllamaProvider } from './ollama.js';
+import { ConfigurationError } from '../../utils/errors.js';
+/**
+ * Create an LLM provider from configuration.
+ * @param providerName - Name of the provider (e.g., "openai", "claude", "ollama")
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns LLM provider instance
+ */
+export function createLLMProvider(providerName, config, projectRoot = process.cwd()) {
+    const providerConfig = config.llm[providerName];
+    if (!providerConfig) {
+        throw new ConfigurationError(`LLM provider "${providerName}" not found in configuration`);
+    }
+    // Handle OpenAI
+    if (providerName === 'openai') {
+        if (!providerConfig.API_KEY || !providerConfig.MODEL_NAME) {
+            throw new ConfigurationError('OpenAI provider requires API_KEY and MODEL_NAME');
+        }
+        return OpenAIProvider.fromConfig(providerConfig.API_KEY, providerConfig.MODEL_NAME, projectRoot);
+    }
+    // Handle Claude
+    if (providerName === 'claude') {
+        if (!providerConfig.API_KEY || !providerConfig.MODEL_NAME) {
+            throw new ConfigurationError('Claude provider requires API_KEY and MODEL_NAME');
+        }
+        return ClaudeProvider.fromConfig(providerConfig.API_KEY, providerConfig.MODEL_NAME, projectRoot);
+    }
+    // Handle Ollama
+    if (providerName === 'ollama') {
+        // Ollama provider - MODEL_NAME is required
+        if (!providerConfig.MODEL_NAME) {
+            throw new ConfigurationError('Ollama provider requires MODEL_NAME to be set in config.yaml');
+        }
+        return OllamaProvider.fromConfig(providerConfig.MODEL_NAME, projectRoot);
+    }
+    throw new ConfigurationError(`Unsupported LLM provider: ${providerName}`);
+}
+/**
+ * Get the default LLM provider from configuration.
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns Default LLM provider instance
+ */
+export function getDefaultLLMProvider(config, projectRoot = process.cwd()) {
+    // Find the provider marked as default
+    for (const [providerName, providerConfig] of Object.entries(config.llm)) {
+        if (providerConfig.default) {
+            return createLLMProvider(providerName, config, projectRoot);
+        }
+    }
+    // If no default, use the first provider
+    const firstProviderName = Object.keys(config.llm)[0];
+    if (!firstProviderName) {
+        throw new ConfigurationError('No LLM providers configured');
+    }
+    return createLLMProvider(firstProviderName, config, projectRoot);
+}
+/**
+ * Get LLM provider by name or use default.
+ * @param providerName - Optional provider name (e.g., "openai", "claude")
+ * @param config - Syrin configuration
+ * @param projectRoot - Project root directory
+ * @returns LLM provider instance
+ */
+export function getLLMProvider(providerName, config, projectRoot = process.cwd()) {
+    if (providerName) {
+        return createLLMProvider(providerName, config, projectRoot);
+    }
+    return getDefaultLLMProvider(config, projectRoot);
+}
+//# sourceMappingURL=factory.js.map

package/dist/runtime/llm/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LLM provider exports.
+ */
+export * from './types.js';
+export * from './provider.js';
+export * from './openai.js';
+export * from './claude.js';
+export * from './ollama.js';
+export * from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/llm/index.js

@@ -0,0 +1,10 @@
+/**
+ * LLM provider exports.
+ */
+export * from './types.js';
+export * from './provider.js';
+export * from './openai.js';
+export * from './claude.js';
+export * from './ollama.js';
+export * from './factory.js';
+//# sourceMappingURL=index.js.map