sessioncast-cli 2.2.1 → 2.2.2

package/dist/agent/llm-service.d.ts

@@ -6,4 +6,7 @@ export declare class LlmService {
     private callOllama;
     private convertOllamaToOpenAiFormat;
     private callOpenAi;
+    private callAnthropic;
+    private callClaudeCode;
+    private convertAnthropicToOpenAiFormat;
 }

package/dist/agent/llm-service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmService = void 0;
+const child_process_1 = require("child_process");
 class LlmService {
     constructor(config) {
         this.config = config || {
@@ -32,6 +33,10 @@ class LlmService {
                     return await this.callOllama(actualModel, messages || [], temperature, maxTokens);
                 case 'openai':
                     return await this.callOpenAi(actualModel, messages || [], temperature, maxTokens);
+                case 'anthropic':
+                    return await this.callAnthropic(actualModel, messages || [], temperature, maxTokens);
+                case 'claude-code':
+                    return await this.callClaudeCode(actualModel, messages || [], maxTokens);
                 default:
                     return {
                         id: '',
@@ -152,5 +157,202 @@ class LlmService {
         }
         return await response.json();
     }
+    async callAnthropic(model, messages, temperature, maxTokens) {
+        const baseUrl = this.config.baseUrl || 'https://api.anthropic.com';
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            return {
+                id: '',
+                object: 'error',
+                created: Date.now(),
+                model: '',
+                choices: [],
+                error: {
+                    message: 'Anthropic API key not configured',
+                    type: 'configuration_error'
+                }
+            };
+        }
+        // Separate system message from user/assistant messages
+        let systemPrompt;
+        const chatMessages = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemPrompt = msg.content;
+            }
+            else {
+                chatMessages.push({ role: msg.role, content: msg.content });
+            }
+        }
+        const requestBody = {
+            model,
+            messages: chatMessages,
+            max_tokens: maxTokens || 1024
+        };
+        if (systemPrompt) {
+            requestBody.system = systemPrompt;
+        }
+        if (temperature !== undefined) {
+            requestBody.temperature = temperature;
+        }
+        const response = await fetch(`${baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01'
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`Anthropic returned status ${response.status}: ${errorBody}`);
+        }
+        const anthropicResponse = await response.json();
+        return this.convertAnthropicToOpenAiFormat(anthropicResponse, model);
+    }
+    async callClaudeCode(model, messages, maxTokens) {
+        // Build prompt from messages
+        const parts = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                parts.push(`[System] ${msg.content}`);
+            }
+            else if (msg.role === 'user') {
+                parts.push(msg.content);
+            }
+            else if (msg.role === 'assistant') {
+                parts.push(`[Assistant] ${msg.content}`);
+            }
+        }
+        const prompt = parts.join('\n\n');
+        const args = ['-p', '--output-format', 'json', '--no-session-persistence'];
+        // Map model names: 'sonnet', 'opus', 'haiku' or full model ID
+        if (model && model !== 'default') {
+            args.push('--model', model);
+        }
+        return new Promise((resolve) => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.CLAUDE_CODE;
+            const proc = (0, child_process_1.spawn)('claude', args, {
+                env,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            // Send prompt via stdin
+            proc.stdin.write(prompt);
+            proc.stdin.end();
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => { stdout += data.toString(); });
+            proc.stderr.on('data', (data) => { stderr += data.toString(); });
+            const timer = setTimeout(() => {
+                proc.kill();
+                resolve({
+                    id: '',
+                    object: 'error',
+                    created: Math.floor(Date.now() / 1000),
+                    model,
+                    choices: [],
+                    error: { message: 'Claude Code timed out after 120s', type: 'timeout' }
+                });
+            }, 120000);
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code !== 0) {
+                    resolve({
+                        id: '',
+                        object: 'error',
+                        created: Math.floor(Date.now() / 1000),
+                        model,
+                        choices: [],
+                        error: {
+                            message: `Claude Code exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`,
+                            type: 'internal_error'
+                        }
+                    });
+                    return;
+                }
+                try {
+                    // claude --output-format json returns a JSON array of events
+                    // Find the "result" event which contains the final response
+                    const events = JSON.parse(stdout);
+                    const resultEvent = Array.isArray(events)
+                        ? events.find((e) => e.type === 'result')
+                        : events;
+                    const content = resultEvent?.result || '';
+                    const sessionId = resultEvent?.session_id || '';
+                    const usage = resultEvent?.usage || {};
+                    resolve({
+                        id: sessionId || `claude-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'claude-code',
+                        choices: [{
+                                index: 0,
+                                message: {
+                                    role: 'assistant',
+                                    content
+                                },
+                                finish_reason: 'stop'
+                            }],
+                        usage: {
+                            prompt_tokens: usage.input_tokens || 0,
+                            completion_tokens: usage.output_tokens || 0,
+                            total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+                        }
+                    });
+                }
+                catch (parseError) {
+                    // Fallback: treat stdout as plain text
+                    resolve({
+                        id: `claude-${Math.random().toString(36).substring(2, 10)}`,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: model || 'claude-code',
+                        choices: [{
+                                index: 0,
+                                message: {
+                                    role: 'assistant',
+                                    content: stdout.trim()
+                                },
+                                finish_reason: 'stop'
+                            }],
+                        usage: {
+                            prompt_tokens: 0,
+                            completion_tokens: 0,
+                            total_tokens: 0
+                        }
+                    });
+                }
+            });
+        });
+    }
+    convertAnthropicToOpenAiFormat(anthropicResponse, model) {
+        const content = (anthropicResponse.content || [])
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
+        const usage = anthropicResponse.usage || {};
+        return {
+            id: anthropicResponse.id || `msg-${Math.random().toString(36).substring(2, 10)}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: anthropicResponse.model || model,
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content
+                    },
+                    finish_reason: anthropicResponse.stop_reason === 'end_turn' ? 'stop' : (anthropicResponse.stop_reason || 'stop')
+                }],
+            usage: {
+                prompt_tokens: usage.input_tokens || 0,
+                completion_tokens: usage.output_tokens || 0,
+                total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+            }
+        };
+    }
 }
 exports.LlmService = LlmService;

package/dist/agent/types.d.ts

@@ -34,7 +34,7 @@ export interface ExecConfig {
 }
 export interface LlmConfig {
     enabled: boolean;
-    provider: 'ollama' | 'openai';
+    provider: 'ollama' | 'openai' | 'anthropic' | 'claude-code';
     baseUrl: string;
     model: string;
     apiKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessioncast-cli",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "SessionCast CLI - Control your agents from anywhere",
   "main": "dist/index.js",
   "bin": {