@exreve/exk 1.0.60 → 1.0.62

package/dist/cli/piBackend.js

@@ -0,0 +1,391 @@
+/**
+ * Pi.dev Agent SDK Backend
+ *
+ * Implements AgentBackend using @mariozechner/pi-coding-agent SDK.
+ *
+ * Key differences from Claude Agent SDK:
+ * - Pi runs in-process (no subprocess spawning)
+ * - Uses event subscription model instead of async iterable
+ * - Different tool registration (defineTool + TypeBox vs createSdkMcpServer + Zod)
+ * - Session management via SessionManager instead of resume IDs
+ * - Multi-provider support is first-class via AuthStorage + ModelRegistry
+ *
+ * NOTE: This backend requires @mariozechner/pi-coding-agent to be installed.
+ * If not available, the backend factory will fall back to ClaudeBackend.
+ */
+import { executeAnalyzeImage, executeSendFile, executeBrowserQuery } from './sharedTools.js';
+// Conditional import — will be undefined if package not installed
+// @ts-expect-error — Pi SDK is an optional dependency, may not be installed
+let piSdk;
+try {
+    // @ts-expect-error — optional dependency
+    piSdk = await import('@mariozechner/pi-coding-agent');
+}
+catch {
+    // Pi SDK not installed — this backend will be unavailable
+}
+export class PiBackend {
+    id = 'pi';
+    activeSessions = new Map(); // sessionId -> AgentSession
+    isAvailable() {
+        return piSdk !== undefined;
+    }
+    async *executePrompt(prompt, config) {
+        if (!piSdk) {
+            throw new Error('Pi SDK (@mariozechner/pi-coding-agent) is not installed. Install with: npm install @mariozechner/pi-coding-agent');
+        }
+        const { cwd, apiKey, model, provider, signal, attachmentDir, routingSessionId, routingPromptId, } = config;
+        // Set up auth and model registry
+        const authStorage = piSdk.AuthStorage.create();
+        const modelRegistry = piSdk.ModelRegistry.create(authStorage);
+        // For custom providers (Z.ai, MiniMax, etc.), set runtime API key
+        if (provider && apiKey) {
+            authStorage.setRuntimeApiKey(provider, apiKey);
+        }
+        else if (apiKey) {
+            // Default: assume anthropic provider
+            authStorage.setRuntimeApiKey('anthropic', apiKey);
+        }
+        // Build custom tools (equivalent of MCP tools in Claude SDK)
+        const customTools = [];
+        customTools.push(this.createAnalyzeImageTool(attachmentDir));
+        customTools.push(this.createSendFileTool(attachmentDir));
+        customTools.push(this.createBrowserQueryTool(routingSessionId, routingPromptId));
+        // Create session options
+        const sessionOpts = {
+            cwd,
+            authStorage,
+            modelRegistry,
+            sessionManager: piSdk.SessionManager.inMemory(),
+            customTools,
+        };
+        // Set model if specified
+        if (model) {
+            try {
+                // Try to find a built-in model first
+                const builtInModel = piSdk.getModel?.('anthropic', model);
+                if (builtInModel) {
+                    sessionOpts.model = builtInModel;
+                }
+                else {
+                    // Try as a custom model — Pi supports custom providers via models.json
+                    // For now, we try the model string directly
+                    const found = modelRegistry.find(provider || 'anthropic', model);
+                    if (found) {
+                        sessionOpts.model = found;
+                    }
+                    // If not found, Pi will use its default model
+                }
+            }
+            catch {
+                // Model not found — Pi will use default
+            }
+        }
+        // Create the agent session
+        const { session } = await piSdk.createAgentSession(sessionOpts);
+        const sessionKey = `${cwd}:${Date.now()}`;
+        this.activeSessions.set(sessionKey, session);
+        // Create event queue — Pi uses subscribe(), we need to bridge to async iterable
+        const eventQueue = [];
+        let resolveEvent = null;
+        let streamDone = false;
+        let streamError = null;
+        // Subscribe to Pi events and translate to BackendEvent
+        const unsubscribe = session.subscribe((event) => {
+            const backendEvent = this.translateEvent(event);
+            if (backendEvent) {
+                if (resolveEvent) {
+                    // Someone is waiting — resolve immediately
+                    const r = resolveEvent;
+                    resolveEvent = null;
+                    r({ value: backendEvent, done: false });
+                }
+                else {
+                    eventQueue.push(backendEvent);
+                }
+            }
+        });
+        // Listen for agent completion
+        session.prompt(prompt).then(() => {
+            // Prompt completed — drain remaining events then signal done
+            streamDone = true;
+            if (resolveEvent) {
+                const r = resolveEvent;
+                resolveEvent = null;
+                r({ value: undefined, done: true });
+            }
+        }).catch((err) => {
+            streamError = err;
+            streamDone = true;
+            if (resolveEvent) {
+                const r = resolveEvent;
+                resolveEvent = null;
+                r({ value: undefined, done: true });
+            }
+        });
+        // Handle abort signal
+        if (signal) {
+            const onAbort = () => {
+                session.abort();
+                streamDone = true;
+                if (resolveEvent) {
+                    const r = resolveEvent;
+                    resolveEvent = null;
+                    r({ value: undefined, done: true });
+                }
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        // Yield events as async generator
+        try {
+            while (!streamDone || eventQueue.length > 0) {
+                if (streamError) {
+                    throw streamError;
+                }
+                if (eventQueue.length > 0) {
+                    yield eventQueue.shift();
+                    continue;
+                }
+                if (streamDone) {
+                    break;
+                }
+                // Wait for next event
+                const event = await new Promise((resolve) => {
+                    resolveEvent = resolve;
+                });
+                if (event.done)
+                    break;
+                yield event.value;
+            }
+        }
+        finally {
+            unsubscribe();
+            session.dispose();
+            this.activeSessions.delete(sessionKey);
+        }
+    }
+    /**
+     * Translate a Pi SDK event to our normalized BackendEvent format.
+     */
+    translateEvent(event) {
+        switch (event.type) {
+            // Text streaming from assistant
+            case 'message_update': {
+                const sub = event.assistantMessageEvent;
+                if (sub?.type === 'text_delta') {
+                    // Accumulate into an assistant message event
+                    // Pi streams text deltas — we batch these into assistant_message events
+                    return {
+                        type: 'assistant_message',
+                        raw: { type: 'text_delta', text: sub.delta },
+                    };
+                }
+                if (sub?.type === 'thinking_delta') {
+                    // Thinking output — emit as system event
+                    return {
+                        type: 'system',
+                        raw: { type: 'thinking_delta', text: sub.delta },
+                        subtype: 'thinking',
+                    };
+                }
+                return null;
+            }
+            // Tool execution
+            case 'tool_execution_start': {
+                return {
+                    type: 'tool_progress',
+                    raw: event,
+                    toolName: event.toolName,
+                };
+            }
+            case 'tool_execution_update': {
+                return {
+                    type: 'tool_progress',
+                    raw: event,
+                    toolName: event.toolName,
+                };
+            }
+            case 'tool_execution_end': {
+                const toolResult = event.result;
+                return {
+                    type: 'tool_result',
+                    result: toolResult?.content || toolResult,
+                    toolName: event.toolName || null,
+                    toolUseId: event.toolCallId || null,
+                };
+            }
+            // Message lifecycle
+            case 'message_start': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: 'message_start',
+                };
+            }
+            case 'message_end': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: 'message_end',
+                };
+            }
+            // Agent lifecycle
+            case 'agent_start': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: 'agent_start',
+                };
+            }
+            case 'agent_end': {
+                // Agent finished — this is the final event
+                // Extract usage from the last message if available
+                return {
+                    type: 'result',
+                    raw: event,
+                    isError: false,
+                    usage: event.usage ? {
+                        inputTokens: event.usage.input_tokens || 0,
+                        outputTokens: event.usage.output_tokens || 0,
+                    } : undefined,
+                };
+            }
+            // Turn lifecycle
+            case 'turn_start': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: 'turn_start',
+                };
+            }
+            case 'turn_end': {
+                // A complete assistant turn — this maps well to our assistant_message
+                const message = event.message;
+                const toolUses = [];
+                // Extract tool use info from message content blocks
+                if (message?.content && Array.isArray(message.content)) {
+                    for (const block of message.content) {
+                        if (block.type === 'tool_use' && block.id && block.name) {
+                            toolUses.push({ id: block.id, name: block.name });
+                        }
+                    }
+                }
+                return {
+                    type: 'assistant_message',
+                    raw: message,
+                    toolUses: toolUses.length > 0 ? toolUses : undefined,
+                };
+            }
+            // Queue events
+            case 'queue_update': {
+                return {
+                    type: 'progress',
+                    message: 'Queue updated',
+                    raw: event,
+                };
+            }
+            // Compaction
+            case 'compaction_start':
+            case 'compaction_end': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: event.type,
+                };
+            }
+            // Retry
+            case 'auto_retry_start':
+            case 'auto_retry_end': {
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: event.type,
+                };
+            }
+            default:
+                // Unknown event — emit as system
+                return {
+                    type: 'system',
+                    raw: event,
+                    subtype: `pi_${event.type}`,
+                };
+        }
+    }
+    // ============ Custom Tools (Pi SDK defineTool format) ============
+    // These use the same shared executors as the Claude backend (sharedTools.ts)
+    createAnalyzeImageTool(attachmentDir) {
+        if (!piSdk)
+            return null;
+        const sharedConfig = { attachmentDir };
+        return piSdk.defineTool({
+            name: 'analyze_image',
+            label: 'Analyze Image',
+            description: 'Analyze one or more image files using a vision model. Pass the path to an image file and a question.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    image_path: { type: 'string', description: 'Path to the image file to analyze' },
+                    question: { type: 'string', description: 'Question about the image' },
+                },
+                required: ['image_path', 'question'],
+            },
+            execute: async (_toolCallId, params) => {
+                return executeAnalyzeImage({ image_path: params.image_path, question: params.question }, sharedConfig);
+            },
+        });
+    }
+    createSendFileTool(attachmentDir) {
+        if (!piSdk)
+            return null;
+        const sharedConfig = { attachmentDir };
+        return piSdk.defineTool({
+            name: 'send_file',
+            label: 'Send File',
+            description: 'Send a file to the user for display in chat.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: { type: 'string', description: 'Path to a local file' },
+                    data: { type: 'string', description: 'Base64-encoded file content' },
+                    mime_type: { type: 'string', description: 'MIME type' },
+                    filename: { type: 'string', description: 'Display name' },
+                },
+            },
+            execute: async (_toolCallId, params) => {
+                return executeSendFile(params, sharedConfig);
+            },
+        });
+    }
+    createBrowserQueryTool(sessionId, promptId) {
+        if (!piSdk)
+            return null;
+        const sharedConfig = { sessionId, promptId };
+        return piSdk.defineTool({
+            name: 'browser_query',
+            label: 'Browser Query',
+            description: 'Launch a headless browser to automate web tasks.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Natural language task' },
+                    maxSteps: { type: 'number', description: 'Max steps (default 20)' },
+                },
+                required: ['query'],
+            },
+            execute: async (_toolCallId, params) => {
+                return executeBrowserQuery({ query: params.query, maxSteps: params.maxSteps }, sharedConfig);
+            },
+        });
+    }
+    async dispose() {
+        for (const [_key, session] of this.activeSessions) {
+            try {
+                session.dispose();
+            }
+            catch { /* ignore */ }
+        }
+        this.activeSessions.clear();
+    }
+}
+/** Singleton instance */
+export const piBackend = new PiBackend();

package/dist/cli/sessionHandlers.js

@@ -111,7 +111,7 @@ export function registerSessionHandlers(socket, foreground, activeSessions, getS
     });
     socket.on('session:prompt', async (data) => {
         try {
-            const { sessionId, prompt, projectPath: providedProjectPath, promptId, enhancers, model } = data;
+            const { sessionId, prompt, projectPath: providedProjectPath, promptId, enhancers, model, agentBackend } = data;
             if (!promptId) {
                 if (foreground) {
                     console.error(`✗ Missing required promptId for session: ${sessionId}`);
@@ -127,7 +127,7 @@ export function registerSessionHandlers(socket, foreground, activeSessions, getS
                 socket.emit('session:error', { sessionId, error: 'Session not found or projectPath missing' });
                 return;
             }
-            activeSessions.set(sessionId, { projectPath, currentPromptId: promptId, model });
+            activeSessions.set(sessionId, { projectPath, currentPromptId: promptId, model, agentBackend });
             const capturedPromptId = promptId;
             if (foreground) {
                 console.log(`\n[CLI] 📤 Received prompt for session: ${sessionId}, promptId: ${capturedPromptId}`);
@@ -142,6 +142,7 @@ export function registerSessionHandlers(socket, foreground, activeSessions, getS
                 projectPath,
                 promptId: capturedPromptId,
                 model: model,
+                agentBackend: agentBackend,
                 attachments: data.attachments,
                 onStatusUpdate: (status) => {
                     if (!capturedPromptId) {

package/dist/cli/sharedTools.js

@@ -0,0 +1,259 @@
+/**
+ * Shared Tool Executors
+ *
+ * Provider-agnostic implementations of custom tools (analyze_image, send_file, browser_query).
+ * These functions contain the actual business logic and can be wrapped by any agent SDK
+ * (Claude Agent SDK MCP tools, Pi SDK defineTool, etc.).
+ *
+ * Each executor takes typed parameters and returns a standardized result.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getOpenrouterApiKey, getApiUrl } from './agentSession.js';
+// ============ Constants ============
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
+const MIME_MAP = {
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+    gif: 'image/gif', webp: 'image/webp', bmp: 'image/bmp',
+    svg: 'image/svg+xml', ico: 'image/x-icon', tiff: 'image/tiff', tif: 'image/tiff',
+    avif: 'image/avif',
+    mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
+    m4a: 'audio/mp4', flac: 'audio/flac', aac: 'audio/aac',
+    wma: 'audio/x-ms-wma', opus: 'audio/opus',
+    mp4: 'video/mp4', webm: 'video/webm', mkv: 'video/x-matroska',
+    avi: 'video/x-msvideo', mov: 'video/quicktime', wmv: 'video/x-ms-wmv',
+    m4v: 'video/mp4', '3gp': 'video/3gpp',
+    pdf: 'application/pdf',
+    txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
+    json: 'application/json', xml: 'text/xml', yaml: 'text/yaml', yml: 'text/yaml',
+    toml: 'text/plain', html: 'text/html', htm: 'text/html',
+    css: 'text/css', scss: 'text/x-scss', less: 'text/x-less',
+    js: 'text/javascript', mjs: 'text/javascript', cjs: 'text/javascript',
+    ts: 'text/typescript', tsx: 'text/typescript',
+    jsx: 'text/javascript', py: 'text/x-python', rs: 'text/x-rust',
+    go: 'text/x-go', java: 'text/x-java', c: 'text/x-c', cpp: 'text/x-c++',
+    h: 'text/x-c', hpp: 'text/x-c++', rb: 'text/x-ruby', php: 'text/x-php',
+    sh: 'text/x-shellscript', bash: 'text/x-shellscript', zsh: 'text/x-shellscript',
+    sql: 'text/x-sql', graphql: 'text/graphql', vue: 'text/x-vue',
+    svelte: 'text/x-svelte', dart: 'text/x-dart', swift: 'text/x-swift',
+    kt: 'text/x-kotlin', scala: 'text/x-scala', lua: 'text/x-lua',
+    r: 'text/x-r', dockerfile: 'text/x-dockerfile',
+};
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'tiff', 'tif', 'avif']);
+const MAX_IMAGE_DIMENSION = 2048;
+const MAX_IMAGE_BYTES = 2 * 1024 * 1024;
+// ============ Helpers ============
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    return MIME_MAP[ext] || 'application/octet-stream';
+}
+function isImageFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    return IMAGE_EXTENSIONS.has(ext);
+}
+async function compressImage(buf) {
+    // Dynamic import of sharp — it's an optional dependency
+    let sharp;
+    try {
+        sharp = (await import('sharp')).default;
+    }
+    catch {
+        return { data: buf, mime: 'image/jpeg' };
+    }
+    const metadata = await sharp(buf).metadata();
+    const { width = 0, height = 0, size = 0 } = metadata;
+    const needsResize = width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION;
+    const needsCompress = (size || buf.length) > MAX_IMAGE_BYTES;
+    if (!needsResize && !needsCompress) {
+        const fmt = metadata.format || 'jpeg';
+        const mime = fmt === 'png' ? 'image/png' : fmt === 'webp' ? 'image/webp' : 'image/jpeg';
+        return { data: buf, mime };
+    }
+    let pipeline = sharp(buf)
+        .resize(MAX_IMAGE_DIMENSION, MAX_IMAGE_DIMENSION, { fit: 'inside', withoutEnlargement: true });
+    if (metadata.hasAlpha) {
+        pipeline = pipeline.webp({ quality: 80 });
+        return { data: await pipeline.toBuffer(), mime: 'image/webp' };
+    }
+    pipeline = pipeline.jpeg({ quality: 80 });
+    return { data: await pipeline.toBuffer(), mime: 'image/jpeg' };
+}
+async function fileToDataUri(filePath) {
+    try {
+        const buf = fs.readFileSync(filePath);
+        if (isImageFile(filePath)) {
+            const { data, mime } = await compressImage(buf);
+            return `data:${mime};base64,${data.toString('base64')}`;
+        }
+        const mime = getMimeType(filePath);
+        return `data:${mime};base64,${buf.toString('base64')}`;
+    }
+    catch {
+        return null;
+    }
+}
+// ============ Tool Executors ============
+/**
+ * analyze_image — analyze an image file using a vision model via OpenRouter.
+ */
+export async function executeAnalyzeImage(args, config) {
+    const workDir = config.attachmentDir || os.tmpdir();
+    const apiKey = getOpenrouterApiKey();
+    if (!apiKey) {
+        return { content: [{ type: 'text', text: 'Error: OPENROUTER_API_KEY not configured.' }], isError: true };
+    }
+    try {
+        const imagePath = path.resolve(workDir, args.image_path);
+        if (!fs.existsSync(imagePath)) {
+            return { content: [{ type: 'text', text: `Error: Image file not found: ${args.image_path}` }], isError: true };
+        }
+        const dataUri = await fileToDataUri(imagePath);
+        if (!dataUri) {
+            return { content: [{ type: 'text', text: `Error: Could not read image file: ${args.image_path}` }], isError: true };
+        }
+        const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify({
+                model: 'qwen/qwen3.5-27b',
+                messages: [{ role: 'user', content: [
+                            { type: 'text', text: args.question },
+                            { type: 'image_url', image_url: { url: dataUri } },
+                        ] }],
+            }),
+            signal: AbortSignal.timeout(60_000),
+        });
+        const raw = await res.text();
+        if (!res.ok) {
+            return { content: [{ type: 'text', text: `Error from vision API (${res.status}): ${raw.slice(0, 500)}` }], isError: true };
+        }
+        const parsed = JSON.parse(raw);
+        return { content: [{ type: 'text', text: parsed.choices?.[0]?.message?.content || raw }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error analyzing image: ${error.message}` }], isError: true };
+    }
+}
+/**
+ * send_file — send a file to the user for display in chat.
+ */
+export async function executeSendFile(args, config) {
+    const workDir = config.attachmentDir || os.tmpdir();
+    try {
+        let dataUri;
+        let mimeType;
+        let fileName;
+        let fileSize;
+        if (args.file_path) {
+            const filePath = path.resolve(workDir, args.file_path);
+            if (!fs.existsSync(filePath)) {
+                return { content: [{ type: 'text', text: `Error: File not found: ${args.file_path}` }], isError: true };
+            }
+            const stat = fs.statSync(filePath);
+            fileSize = stat.size;
+            if (fileSize > MAX_FILE_SIZE) {
+                return { content: [{ type: 'text', text: `Error: File too large (${(fileSize / (1024 * 1024)).toFixed(1)} MB). Maximum size is ${MAX_FILE_SIZE / (1024 * 1024)} MB.` }], isError: true };
+            }
+            const buf = fs.readFileSync(filePath);
+            mimeType = args.mime_type || getMimeType(filePath);
+            fileName = args.filename || path.basename(filePath);
+            dataUri = `data:${mimeType};base64,${buf.toString('base64')}`;
+        }
+        else if (args.data) {
+            mimeType = args.mime_type || 'application/octet-stream';
+            fileName = args.filename || 'file';
+            const rawBase64 = args.data.replace(/^data:[^;]+;base64,/, '');
+            fileSize = Math.floor(rawBase64.length * 0.75);
+            if (fileSize > MAX_FILE_SIZE) {
+                return { content: [{ type: 'text', text: `Error: Data too large (~${(fileSize / (1024 * 1024)).toFixed(1)} MB). Maximum size is ${MAX_FILE_SIZE / (1024 * 1024)} MB.` }], isError: true };
+            }
+            dataUri = `data:${mimeType};base64,${rawBase64}`;
+        }
+        else {
+            return { content: [{ type: 'text', text: 'Error: Either file_path or data must be provided.' }], isError: true };
+        }
+        const result = JSON.stringify({
+            _type: 'send_file',
+            data: dataUri,
+            mime_type: mimeType,
+            filename: fileName,
+            size: fileSize,
+        });
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error sending file: ${error.message}` }], isError: true };
+    }
+}
+/**
+ * browser_query — launch a headless browser to automate web tasks via the backend.
+ */
+export async function executeBrowserQuery(args, config) {
+    const apiUrl = getApiUrl();
+    let deviceId = '';
+    try {
+        const deviceIdPath = path.join(os.homedir(), '.talk-to-code', 'device-id.json');
+        const data = fs.readFileSync(deviceIdPath, 'utf-8');
+        deviceId = JSON.parse(data).deviceId || '';
+    }
+    catch { /* no device ID */ }
+    try {
+        const body = {
+            query: args.query,
+            maxSteps: args.maxSteps || 20,
+        };
+        if (args.schema) {
+            try {
+                body.schema = JSON.parse(args.schema);
+            }
+            catch {
+                body.schema = args.schema;
+            }
+        }
+        if (args.country)
+            body.country = args.country;
+        if (args.mobile)
+            body.mobile = args.mobile;
+        if (config.sessionId)
+            body.sessionId = config.sessionId;
+        if (config.promptId)
+            body.promptId = config.promptId;
+        const res = await fetch(`${apiUrl}/api/browser/query`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(deviceId ? { 'X-Device-ID': deviceId } : {}),
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10 * 60 * 1000),
+        });
+        const raw = await res.text();
+        if (!res.ok) {
+            return {
+                content: [{ type: 'text', text: `Error from browser agent (${res.status}): ${raw.slice(0, 500)}` }],
+                isError: true,
+            };
+        }
+        const result = JSON.parse(raw);
+        const summary = [
+            `Browser query completed in ${result.steps} steps.`,
+            result.answer ? `\n\n**Answer:** ${result.answer}` : '',
+            result.data ? `\n\n**Structured Data:**\n\`\`\`json\n${JSON.stringify(result.data, null, 2)}\n\`\`\`` : '',
+            result.logs?.length ? `\n\n**Log:**\n${result.logs.slice(-5).join('\n')}` : '',
+        ].join('');
+        return { content: [{ type: 'text', text: summary }] };
+    }
+    catch (error) {
+        if (error.name === 'TimeoutError') {
+            return {
+                content: [{ type: 'text', text: 'Browser query timed out after 10 minutes. Try reducing maxSteps or simplifying the query.' }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: `Error running browser query: ${error.message}` }],
+            isError: true,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {