@a5c-ai/agent-mux-adapters 0.4.0 → 0.4.2

package/dist/claude-agent-sdk-adapter.js

@@ -1,20 +1,74 @@
-/**
- * ClaudeAgentSdkAdapter — Direct Claude Agent SDK integration.
- *
- * Uses the Claude Agent SDK directly instead of the Claude Code CLI for
- * better performance, more granular control, and native programmatic access
- * to Claude's advanced agent capabilities.
- */
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
 import { BaseProgrammaticAdapter } from './programmatic-adapter-base.js';
+import { createVirtualRuntimeHookCapabilities } from './shared/runtime-hooks-virtual.js';
 import { mcpListPlugins, mcpInstallPlugin, mcpUninstallPlugin } from './mcp-plugins.js';
 import { listJsonlFiles, parseJsonlSessionFile, readJsonFile, writeJsonFileAtomic, } from './session-fs.js';
+const require = createRequire(import.meta.url);
+class AsyncQueue {
+    values = [];
+    waiters = [];
+    closed = false;
+    failure = null;
+    enqueue(value) {
+        if (this.closed) {
+            throw new Error('Queue is closed');
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve({ value, done: false });
+            return;
+        }
+        this.values.push(value);
+    }
+    fail(error) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.failure = error;
+        for (const waiter of this.waiters.splice(0)) {
+            waiter.reject(error);
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) {
+            waiter.resolve({ value: undefined, done: true });
+        }
+    }
+    async next() {
+        if (this.values.length > 0) {
+            return { value: this.values.shift(), done: false };
+        }
+        if (this.failure != null) {
+            throw this.failure;
+        }
+        if (this.closed) {
+            return { value: undefined, done: true };
+        }
+        return new Promise((resolve, reject) => {
+            this.waiters.push({ resolve, reject });
+        });
+    }
+    async return() {
+        this.close();
+        return { value: undefined, done: true };
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+}
 export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
     agent = 'claude-agent-sdk';
     displayName = 'Claude (Agent SDK)';
-    minVersion = '0.1.0';
-    hostEnvSignals = ['ANTHROPIC_API_KEY', 'CLAUDE_AGENT_API_KEY'];
+    minVersion = '0.2.0';
+    hostEnvSignals = ['ANTHROPIC_API_KEY', 'CLAUDE_AGENT_API_KEY', 'CLAUDE_CODE_ENTRYPOINT'];
     capabilities = {
         agent: 'claude-agent-sdk',
         canResume: true,
@@ -29,11 +83,14 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
         supportsParallelToolCalls: true,
         requiresToolApproval: true,
         approvalModes: ['yolo', 'prompt', 'deny'],
+        runtimeHooks: createVirtualRuntimeHookCapabilities(),
         supportsThinking: true,
         thinkingEffortLevels: ['low', 'medium', 'high', 'max'],
         supportsThinkingBudgetTokens: true,
         supportsJsonMode: true,
         supportsStructuredOutput: true,
+        structuredSessionTransport: 'persistent',
+        sessionControlPlane: 'self-managed',
         supportsSkills: true,
         supportsAgentsMd: true,
         skillsFormat: 'file',
@@ -44,7 +101,7 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
         supportsStdinInjection: true,
         supportsImageInput: true,
         supportsImageOutput: false,
-        supportsFileAttachments: true,
+        supportsFileAttachments: false,
         supportsPlugins: true,
         pluginFormats: ['mcp-server'],
         pluginRegistries: [{ name: 'mcp', url: 'https://modelcontextprotocol.io', searchable: false }],
@@ -53,11 +110,11 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
         requiresPty: false,
         authMethods: [
             { type: 'api_key', name: 'API Key', description: 'ANTHROPIC_API_KEY environment variable' },
-            { type: 'oauth', name: 'OAuth', description: 'OAuth-based authentication' },
+            { type: 'oauth', name: 'Claude Login', description: 'Claude Code browser login or stored credentials' },
         ],
-        authFiles: ['.claude.json', '.claude/settings.json'],
+        authFiles: ['.claude.json', '.claude/.credentials.json', '.claude/settings.json'],
         installMethods: [
-            { platform: 'all', type: 'npm', command: 'npm install -g @anthropic-ai/agent-sdk' },
+            { platform: 'all', type: 'npm', command: 'npm install -g @anthropic-ai/claude-agent-sdk' },
         ],
     };
     models = [
@@ -85,7 +142,7 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
             supportsThinkingStreaming: true,
             supportsImageInput: true,
             supportsImageOutput: false,
-            supportsFileInput: true,
+            supportsFileInput: false,
             cliArgKey: 'model',
             cliArgValue: 'claude-sonnet-4-20250514',
             lastUpdated: '2025-05-14',
@@ -115,7 +172,7 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
             supportsThinkingStreaming: true,
             supportsImageInput: true,
             supportsImageOutput: false,
-            supportsFileInput: true,
+            supportsFileInput: false,
             cliArgKey: 'model',
             cliArgValue: 'claude-opus-4-20250514',
             lastUpdated: '2025-05-14',
@@ -132,213 +189,189 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
         configFormat: 'json',
         supportsProjectConfig: true,
     };
-    async *execute(options) {
+    execute(options) {
         this.validateRunOptions(options);
         const runId = this.generateRunId();
         const modelId = this.resolveModel(options);
-        const prompt = this.normalizePrompt(options.prompt);
-        // Check authentication
-        const authState = await this.detectAuth();
-        if (authState.status !== 'authenticated') {
-            yield this.createErrorEvent(runId, 'AUTH_MISSING', 'Anthropic API key not found', false);
-            return;
-        }
-        try {
-            // Emit session start
-            yield {
-                ...this.createBaseEvent('session_start', runId),
-                type: 'session_start',
-                sessionId: options.sessionId || runId,
-                resumed: Boolean(options.sessionId),
-            };
-            // Create Claude Agent SDK client (in real implementation)
-            const client = this.createClaudeAgentClient();
-            // Build messages array
-            const messages = [
-                {
-                    role: 'user',
-                    content: prompt,
-                },
-            ];
-            // Add system prompt if provided
-            const systemPrompt = options.systemPrompt || this.buildDefaultSystemPrompt(options);
-            // Define available tools for Claude agent capabilities
-            const tools = [
-                {
-                    name: 'read_file',
-                    description: 'Read the contents of a file',
-                    input_schema: {
-                        type: 'object',
-                        properties: {
-                            path: {
-                                type: 'string',
-                                description: 'Path to the file to read',
-                            },
-                        },
-                        required: ['path'],
-                    },
-                },
-                {
-                    name: 'write_file',
-                    description: 'Write content to a file',
-                    input_schema: {
-                        type: 'object',
-                        properties: {
-                            path: {
-                                type: 'string',
-                                description: 'Path to the file to write',
-                            },
-                            content: {
-                                type: 'string',
-                                description: 'Content to write to the file',
-                            },
-                        },
-                        required: ['path', 'content'],
-                    },
-                },
-                {
-                    name: 'execute_bash',
-                    description: 'Execute a bash command',
-                    input_schema: {
-                        type: 'object',
-                        properties: {
-                            command: {
-                                type: 'string',
-                                description: 'Bash command to execute',
-                            },
-                        },
-                        required: ['command'],
-                    },
-                },
-                {
-                    name: 'spawn_subagent',
-                    description: 'Spawn a subagent to handle a specific task',
-                    input_schema: {
-                        type: 'object',
-                        properties: {
-                            task: {
-                                type: 'string',
-                                description: 'Task description for the subagent',
-                            },
-                            agent_type: {
-                                type: 'string',
-                                description: 'Type of agent to spawn',
-                                enum: ['claude', 'codex', 'opencode'],
-                            },
-                        },
-                        required: ['task'],
-                    },
-                },
-            ];
-            // Make streaming API call with thinking enabled
-            const stream = await this.createClaudeStream({
-                model: modelId,
-                messages,
-                system: systemPrompt,
-                tools,
-                max_tokens: options.maxTokens || 8192,
-                temperature: 0.1,
-                stream: true,
-                thinking_enabled: true,
-                thinking_effort: options.thinkingEffort || 'medium',
-                thinking_budget_tokens: options.thinkingBudgetTokens,
-            });
-            let textAccumulated = '';
-            let thinkingAccumulated = '';
-            let currentToolCall = null;
-            let inThinking = false;
-            for await (const chunk of stream) {
-                switch (chunk.type) {
-                    case 'message_start':
-                        // Message started - no specific action needed
-                        break;
-                    case 'content_block_start':
-                        if (chunk.content_block?.type === 'text') {
-                            // Text content block started
-                        }
-                        else if (chunk.content_block?.type === 'tool_use') {
-                            // Tool use block started
-                            currentToolCall = {
-                                id: chunk.content_block.id,
-                                name: chunk.content_block.name,
-                                input: '',
-                            };
-                            yield this.createToolCallStartEvent(runId, currentToolCall.id, currentToolCall.name, '');
-                        }
-                        break;
-                    case 'content_block_delta':
-                        if (chunk.delta?.type === 'text_delta' && chunk.delta.text) {
-                            // Check if this is thinking content
-                            if (chunk.delta.text.includes('<thinking>')) {
-                                inThinking = true;
-                            }
-                            if (inThinking) {
-                                // Thinking content
-                                thinkingAccumulated += chunk.delta.text;
-                                yield {
-                                    ...this.createBaseEvent('thinking_delta', runId),
-                                    type: 'thinking_delta',
-                                    delta: chunk.delta.text,
-                                    accumulated: thinkingAccumulated,
-                                };
-                                if (chunk.delta.text.includes('</thinking>')) {
-                                    inThinking = false;
-                                }
-                            }
-                            else {
-                                // Regular text content
-                                textAccumulated += chunk.delta.text;
-                                yield this.createTextDeltaEvent(runId, chunk.delta.text, textAccumulated);
-                            }
-                        }
-                        else if (chunk.delta?.type === 'input_json_delta' && currentToolCall) {
-                            // Tool input streaming
-                            currentToolCall.input += chunk.delta.partial_json || '';
-                            yield {
-                                ...this.createBaseEvent('tool_input_delta', runId),
-                                type: 'tool_input_delta',
-                                toolCallId: currentToolCall.id,
-                                delta: chunk.delta.partial_json || '',
-                                inputAccumulated: currentToolCall.input,
-                            };
-                        }
-                        break;
-                    case 'content_block_stop':
-                        if (currentToolCall) {
-                            // Tool call ready
-                            yield {
-                                ...this.createBaseEvent('tool_call_ready', runId),
-                                type: 'tool_call_ready',
-                                toolCallId: currentToolCall.id,
-                                toolName: currentToolCall.name,
-                                input: currentToolCall.input,
-                            };
-                            // Execute the tool (mock execution)
-                            const toolResult = await this.executeMockTool(currentToolCall.name, currentToolCall.input);
-                            yield this.createToolResultEvent(runId, currentToolCall.id, currentToolCall.name, toolResult, 150 // mock duration
-                            );
-                            currentToolCall = null;
-                        }
-                        break;
-                    case 'message_delta':
-                        // Handle message-level changes
-                        break;
-                    case 'message_stop':
-                        // Message completed
-                        if (chunk.message?.usage) {
-                            const cost = this.extractCostFromUsage(chunk.message.usage, modelId);
-                            if (cost) {
-                                yield this.createCostEvent(runId, cost);
-                            }
-                        }
-                        yield this.createMessageStopEvent(runId, textAccumulated);
-                        break;
+        const events = new AsyncQueue();
+        const prompts = new AsyncQueue();
+        const pendingApprovals = new Map();
+        const pendingInputs = new Map();
+        const toolsByIndex = new Map();
+        const toolsById = new Map();
+        let queryHandle = null;
+        let closed = false;
+        let turnIndex = -1;
+        let textAccumulated = '';
+        let thinkingAccumulated = '';
+        let sessionId;
+        const queueError = (code, message) => {
+            events.enqueue(this.createErrorEvent(runId, code, message, false));
+        };
+        const rejectPending = (reason) => {
+            for (const pending of pendingApprovals.values()) {
+                pending.reject(reason);
+            }
+            pendingApprovals.clear();
+            for (const pending of pendingInputs.values()) {
+                pending.reject(reason);
+            }
+            pendingInputs.clear();
+        };
+        const closeRun = async () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            prompts.close();
+            rejectPending(new Error('Claude Agent SDK session closed'));
+            queryHandle?.close();
+        };
+        const sdkPromise = (async () => {
+            try {
+                const authState = await this.detectAuth();
+                if (authState.status !== 'authenticated') {
+                    queueError('AUTH_MISSING', 'Anthropic authentication not found');
+                    return;
                 }
+                if (options.attachments?.some((attachment) => !this.isImageAttachment(attachment.mimeType, attachment.filePath, attachment.url))) {
+                    queueError('CAPABILITY_ERROR', 'claude-agent-sdk currently supports only image attachments through agent-mux');
+                    return;
+                }
+                const initialMessage = await this.buildUserMessage(this.normalizePrompt(options.prompt), options.attachments);
+                prompts.enqueue(initialMessage);
+                if (options.nonInteractive) {
+                    prompts.close();
+                }
+                const sdk = await this.loadSdkModule();
+                queryHandle = sdk.query({
+                    prompt: prompts,
+                    options: this.buildSdkOptions(options, modelId, async (toolName, input, ctx) => {
+                        const interactionId = ctx.toolUseID || `approval-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                        events.enqueue({
+                            ...this.createBaseEvent('approval_request', runId),
+                            type: 'approval_request',
+                            interactionId,
+                            action: ctx.title || `Allow ${toolName}`,
+                            detail: ctx.description || JSON.stringify(input),
+                            toolName,
+                            riskLevel: this.estimateRiskLevel(toolName),
+                        });
+                        return await new Promise((resolve, reject) => {
+                            pendingApprovals.set(interactionId, { resolve, reject });
+                        });
+                    }, async (request) => {
+                        const interactionId = request.elicitationId || `input-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                        events.enqueue({
+                            ...this.createBaseEvent('input_required', runId),
+                            type: 'input_required',
+                            interactionId,
+                            question: request.title || request.message,
+                            context: request.description || request.url,
+                            source: 'tool',
+                        });
+                        return await new Promise((resolve, reject) => {
+                            pendingInputs.set(interactionId, { resolve, reject });
+                        });
+                    }),
+                });
+                for await (const message of queryHandle) {
+                    const translated = this.translateSdkMessage({
+                        runId,
+                        options,
+                        message,
+                        modelId,
+                        textAccumulated,
+                        thinkingAccumulated,
+                        toolsByIndex,
+                        toolsById,
+                        turnIndex,
+                        sessionId,
+                    });
+                    textAccumulated = translated.textAccumulated;
+                    thinkingAccumulated = translated.thinkingAccumulated;
+                    turnIndex = translated.turnIndex;
+                    sessionId = translated.sessionId;
+                    for (const event of translated.events) {
+                        events.enqueue(event);
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                queueError('INTERNAL', `Claude Agent SDK error: ${message}`);
+            }
+            finally {
+                await closeRun();
+                events.close();
             }
+        })();
+        void sdkPromise;
+        return Object.assign(events, {
+            send: async (text) => {
+                if (closed) {
+                    throw new Error('Claude Agent SDK session is closed');
+                }
+                prompts.enqueue(await this.buildUserMessage(text, []));
+            },
+            respond: async (interactionId, response) => {
+                const pendingApproval = pendingApprovals.get(interactionId);
+                if (pendingApproval) {
+                    pendingApprovals.delete(interactionId);
+                    if (response.type === 'approve') {
+                        events.enqueue({
+                            ...this.createBaseEvent('approval_granted', runId),
+                            type: 'approval_granted',
+                            interactionId,
+                        });
+                        pendingApproval.resolve({ behavior: 'allow' });
+                        return;
+                    }
+                    if (response.type === 'deny') {
+                        events.enqueue({
+                            ...this.createBaseEvent('approval_denied', runId),
+                            type: 'approval_denied',
+                            interactionId,
+                            reason: response.reason,
+                        });
+                        pendingApproval.resolve({ behavior: 'deny', message: response.reason || 'Denied by user' });
+                        return;
+                    }
+                    throw new Error('Approval requests require approve/deny responses');
+                }
+                const pendingInput = pendingInputs.get(interactionId);
+                if (pendingInput) {
+                    pendingInputs.delete(interactionId);
+                    if (response.type !== 'text') {
+                        pendingInput.resolve({ action: 'decline' });
+                        return;
+                    }
+                    pendingInput.resolve({ action: 'accept', content: { response: response.text } });
+                    return;
+                }
+                throw new Error(`No pending Claude SDK interaction with id '${interactionId}'`);
+            },
+            interrupt: async () => {
+                await queryHandle?.interrupt();
+            },
+            close: async () => {
+                await closeRun();
+            },
+        });
+    }
+    async detectInstallation() {
+        try {
+            const sdkEntry = require.resolve('@anthropic-ai/claude-agent-sdk');
+            const pkgPath = path.join(path.dirname(sdkEntry), 'package.json');
+            const pkg = await readJsonFile(pkgPath);
+            return {
+                installed: true,
+                version: pkg?.version ?? undefined,
+                path: sdkEntry,
+            };
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            yield this.createErrorEvent(runId, 'INTERNAL', `SDK error: ${message}`, false);
+        catch {
+            return { installed: false };
         }
     }
     async detectAuth() {
@@ -350,21 +383,32 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
                 identity: `anthropic:...${apiKey.slice(-4)}`,
             };
         }
-        // Check Claude settings file
-        const claudeHome = path.join(os.homedir(), '.claude');
-        const settingsPath = path.join(claudeHome, 'settings.json');
-        try {
-            const settings = await readJsonFile(settingsPath);
-            if (settings?.user?.id) {
-                return {
-                    status: 'authenticated',
-                    method: 'oauth',
-                    identity: `claude:${settings.user.id}`,
-                };
+        for (const credentialsPath of [
+            path.join(os.homedir(), '.claude', '.credentials.json'),
+            path.join(os.homedir(), '.claude.json'),
+            path.join(os.homedir(), '.claude', 'settings.json'),
+        ]) {
+            try {
+                const data = await readJsonFile(credentialsPath);
+                if (data) {
+                    const email = typeof data['email'] === 'string' ? data['email'] : undefined;
+                    const userId = typeof data['userId'] === 'string'
+                        ? data['userId']
+                        : typeof data['user']?.['id'] === 'string'
+                            ? data['user']['id']
+                            : undefined;
+                    if (email || userId || Object.keys(data).length > 0) {
+                        return {
+                            status: 'authenticated',
+                            method: 'oauth',
+                            identity: email ? `claude:${email}` : `claude:${userId ?? 'local'}`,
+                        };
+                    }
+                }
+            }
+            catch {
+                // Ignore missing or invalid auth files.
             }
-        }
-        catch {
-            // Settings file not found or invalid
         }
         return { status: 'unauthenticated' };
     }
@@ -375,31 +419,31 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
             steps: [
                 {
                     step: 1,
-                    description: 'Get an API key from https://console.anthropic.com/',
-                    url: 'https://console.anthropic.com/'
+                    description: 'Get an API key from https://console.anthropic.com/settings/keys',
+                    url: 'https://console.anthropic.com/settings/keys',
                 },
                 {
                     step: 2,
                     description: 'Set the ANTHROPIC_API_KEY environment variable',
-                    command: 'export ANTHROPIC_API_KEY=sk-ant-...'
+                    command: 'export ANTHROPIC_API_KEY=sk-ant-...',
                 },
                 {
                     step: 3,
-                    description: 'Alternatively, authenticate via Claude CLI',
-                    command: 'claude auth'
+                    description: 'Or sign in through Claude Code and let the SDK reuse the stored credentials',
+                    command: 'claude',
                 },
             ],
             envVars: [
-                { name: 'ANTHROPIC_API_KEY', description: 'Anthropic API key', required: true, exampleFormat: 'sk-ant-...' },
-                { name: 'CLAUDE_AGENT_API_KEY', description: 'Claude Agent SDK API key', required: false, exampleFormat: 'sk-ant-...' },
+                { name: 'ANTHROPIC_API_KEY', description: 'Anthropic API key', required: false, exampleFormat: 'sk-ant-...' },
+                { name: 'CLAUDE_AGENT_API_KEY', description: 'Alternate Anthropic API key env var', required: false, exampleFormat: 'sk-ant-...' },
             ],
-            documentationUrls: ['https://docs.anthropic.com/claude/docs'],
-            loginCommand: 'claude auth',
-            verifyCommand: 'claude --version',
+            documentationUrls: ['https://platform.claude.com/docs/en/agent-sdk/overview'],
+            loginCommand: 'claude',
+            verifyCommand: 'node -e "import(\'@anthropic-ai/claude-agent-sdk\').then(() => console.log(\'OK\'))"',
         };
     }
     sessionDir(_cwd) {
-        return path.join(os.homedir(), '.claude', 'sessions');
+        return path.join(os.homedir(), '.claude', 'projects');
     }
     async parseSessionFile(filePath) {
         const parsed = await parseJsonlSessionFile(filePath, 'claude-agent-sdk');
@@ -420,187 +464,375 @@ export class ClaudeAgentSdkAdapter extends BaseProgrammaticAdapter {
         if (!filePath)
             return;
         const existing = (await readJsonFile(filePath)) ?? {};
-        const { agent: _a, source: _s, filePaths: _fp, ...rest } = config;
-        void _a;
-        void _s;
-        void _fp;
+        const { agent: _agent, source: _source, filePaths: _filePaths, ...rest } = config;
+        void _agent;
+        void _source;
+        void _filePaths;
         await writeJsonFileAtomic(filePath, { ...existing, ...rest });
     }
-    // ── MCP Plugin Support ─────────────────────────────────────────────
     async listPlugins() {
         return mcpListPlugins(this.agent);
     }
     async installPlugin(pluginId, options) {
         return mcpInstallPlugin(this.agent, pluginId, options);
     }
-    async uninstallPlugin(pluginId) {
+    async uninstallPlugin(pluginId, _options) {
         return mcpUninstallPlugin(this.agent, pluginId);
     }
-    // ── Private implementation methods ─────────────────────────────────
-    /**
-     * Create Claude Agent SDK client (mock implementation).
-     * In real implementation, this would return an actual Claude Agent SDK client.
-     */
-    createClaudeAgentClient() {
-        // Mock client - in real implementation, this would be:
-        // return new ClaudeAgent({ apiKey: process.env.ANTHROPIC_API_KEY });
-        return {};
+    async loadSdkModule() {
+        return await import('@anthropic-ai/claude-agent-sdk');
     }
-    /**
-     * Create Claude stream (mock implementation).
-     * In real implementation, this would use the Claude Agent SDK.
-     */
-    async createClaudeStream(params) {
-        // Mock streaming response with thinking
-        const mockChunks = [
-            {
-                type: 'message_start',
-                message: {
-                    id: 'msg_123',
-                    type: 'message',
-                    role: 'assistant',
-                    content: [],
-                    model: params.model,
-                    stop_reason: null,
-                    stop_sequence: null,
-                    usage: { input_tokens: 0, output_tokens: 0 },
-                },
-            },
-            // Thinking stream
-            {
-                type: 'content_block_start',
-                content_block: { type: 'text' },
-                index: 0,
-            },
-            {
-                type: 'content_block_delta',
-                delta: { type: 'text_delta', text: '<thinking>\nLet me think about this task. ' },
-                index: 0,
-            },
-            {
-                type: 'content_block_delta',
-                delta: { type: 'text_delta', text: 'I need to analyze the request and determine the best approach.\n</thinking>\n\n' },
-                index: 0,
-            },
-            // Regular response
-            {
-                type: 'content_block_delta',
-                delta: { type: 'text_delta', text: 'I\'ll help you with that task. ' },
-                index: 0,
-            },
-            {
-                type: 'content_block_delta',
-                delta: { type: 'text_delta', text: 'Let me read a file to understand the context better.' },
-                index: 0,
-            },
-            // Tool use
-            {
-                type: 'content_block_start',
-                content_block: {
-                    type: 'tool_use',
-                    id: 'call_123',
-                    name: 'read_file',
-                    input: {}
-                },
-                index: 1,
-            },
-            {
-                type: 'content_block_delta',
-                delta: { type: 'input_json_delta', partial_json: '{"path": ' },
-                index: 1,
-            },
-            {
-                type: 'content_block_delta',
-                delta: { type: 'input_json_delta', partial_json: '"README.md"}' },
-                index: 1,
-            },
-            {
-                type: 'content_block_stop',
-                index: 1,
+    buildSdkOptions(options, modelId, canUseTool, onElicitation) {
+        const permissionMode = this.mapPermissionMode(options.approvalMode);
+        const sdkOptions = {
+            model: modelId,
+            cwd: options.cwd ?? process.cwd(),
+            env: options.env ? { ...process.env, ...options.env } : undefined,
+            resume: options.sessionId ?? options.forkSessionId,
+            forkSession: options.forkSessionId != null,
+            persistSession: options.noSession ? false : true,
+            permissionMode,
+            allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions',
+            canUseTool,
+            onElicitation,
+            includePartialMessages: true,
+            includeHookEvents: true,
+            settingSources: ['user', 'project', 'local'],
+            mcpServers: this.buildMcpServers(options),
+            maxTurns: options.maxTurns,
+            systemPrompt: this.buildSystemPrompt(options),
+            stderr: (data) => {
+                if (data.trim().length > 0) {
+                    // Surface stderr as a debug event via the regular SDK stream handling.
+                }
             },
-            {
-                type: 'message_stop',
-                message: {
-                    id: 'msg_123',
-                    type: 'message',
-                    role: 'assistant',
-                    content: [],
-                    model: params.model,
-                    stop_reason: 'tool_use',
-                    stop_sequence: null,
-                    usage: { input_tokens: 200, output_tokens: 150 },
+        };
+        if (options.thinkingBudgetTokens != null) {
+            sdkOptions.thinking = {
+                type: 'enabled',
+                budgetTokens: options.thinkingBudgetTokens,
+            };
+        }
+        if (options.thinkingEffort) {
+            sdkOptions.effort = options.thinkingEffort === 'max' ? 'max' : options.thinkingEffort;
+        }
+        return sdkOptions;
+    }
+    buildMcpServers(options) {
+        if (!options.mcpServers || options.mcpServers.length === 0) {
+            return undefined;
+        }
+        const servers = {};
+        for (const server of options.mcpServers) {
+            if (server.transport === 'stdio') {
+                servers[server.name] = {
+                    type: 'stdio',
+                    command: server.command,
+                    args: server.args,
+                    env: server.env,
+                };
+                continue;
+            }
+            servers[server.name] = {
+                type: server.transport === 'streamable-http' ? 'http' : 'sse',
+                url: server.url,
+                headers: server.headers,
+            };
+        }
+        return servers;
+    }
+    buildSystemPrompt(options) {
+        if (!options.systemPrompt) {
+            return undefined;
+        }
+        if (options.systemPromptMode === 'append' || options.systemPromptMode == null) {
+            return {
+                type: 'preset',
+                preset: 'claude_code',
+                append: options.systemPrompt,
+            };
+        }
+        if (options.systemPromptMode === 'replace') {
+            return options.systemPrompt;
+        }
+        return {
+            type: 'preset',
+            preset: 'claude_code',
+            append: options.systemPrompt,
+        };
+    }
+    mapPermissionMode(mode) {
+        switch (mode) {
+            case 'yolo':
+                return 'bypassPermissions';
+            case 'deny':
+                return 'dontAsk';
+            default:
+                return 'default';
+        }
+    }
+    estimateRiskLevel(toolName) {
+        const lowered = toolName.toLowerCase();
+        if (lowered.includes('bash') || lowered.includes('delete') || lowered.includes('write') || lowered.includes('edit')) {
+            return 'high';
+        }
+        if (lowered.includes('read') || lowered.includes('grep') || lowered.includes('glob')) {
+            return 'low';
+        }
+        return 'medium';
+    }
+    async buildUserMessage(prompt, attachments = []) {
+        const content = [{ type: 'text', text: prompt }];
+        for (const attachment of attachments ?? []) {
+            const mimeType = await this.resolveMimeType(attachment.mimeType, attachment.filePath, attachment.url);
+            if (!mimeType || !mimeType.startsWith('image/')) {
+                throw new Error('Only image attachments are currently supported for claude-agent-sdk');
+            }
+            const data = await this.readAttachmentAsBase64(attachment);
+            content.push({
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: mimeType,
+                    data,
                 },
-            },
-        ];
+            });
+        }
         return {
-            async *[Symbol.asyncIterator]() {
-                for (const chunk of mockChunks) {
-                    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate streaming delay
-                    yield chunk;
-                }
+            type: 'user',
+            message: {
+                role: 'user',
+                content: attachments && attachments.length > 0 ? content : prompt,
             },
+            parent_tool_use_id: null,
         };
     }
-    /**
-     * Build default system prompt with agent capabilities.
-     */
-    buildDefaultSystemPrompt(options) {
-        let systemPrompt = 'You are Claude, an AI assistant created by Anthropic. You have access to various tools and capabilities:\n\n';
-        systemPrompt += '- read_file: Read file contents\n';
-        systemPrompt += '- write_file: Write content to files\n';
-        systemPrompt += '- execute_bash: Run bash commands\n';
-        systemPrompt += '- spawn_subagent: Delegate tasks to specialized agents\n\n';
-        if (options.approvalMode === 'yolo') {
-            systemPrompt += 'Tool approval is disabled - you can execute tools freely.\n';
-        }
-        else {
-            systemPrompt += 'Always ask for permission before executing potentially dangerous tools.\n';
-        }
-        systemPrompt += '\nProvide helpful, harmless, and honest responses while leveraging these capabilities effectively.';
-        return systemPrompt;
+    isImageAttachment(mimeType, filePath, url) {
+        if (mimeType?.startsWith('image/')) {
+            return true;
+        }
+        const source = filePath ?? url;
+        if (!source) {
+            return false;
+        }
+        return /\.(png|jpe?g|gif|webp|bmp)$/i.test(source);
     }
-    /**
-     * Execute mock tool calls.
-     */
-    async executeMockTool(name, inputJson) {
-        try {
-            const input = JSON.parse(inputJson);
-            switch (name) {
-                case 'read_file':
-                    return `Mock file contents for: ${input.path}`;
-                case 'write_file':
-                    return `Successfully wrote ${input.content.length} characters to ${input.path}`;
-                case 'execute_bash':
-                    return `Executed: ${input.command}\nMock output: Command completed successfully`;
-                case 'spawn_subagent':
-                    return `Spawned ${input.agent_type || 'claude'} subagent for task: ${input.task}`;
-                default:
-                    return `Unknown tool: ${name}`;
+    async readAttachmentAsBase64(attachment) {
+        if (attachment.base64) {
+            return attachment.base64;
+        }
+        if (attachment.filePath) {
+            const data = await fs.readFile(attachment.filePath);
+            return data.toString('base64');
+        }
+        if (attachment.url) {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch attachment from ${attachment.url}: ${response.status}`);
             }
+            const data = Buffer.from(await response.arrayBuffer());
+            return data.toString('base64');
         }
-        catch (error) {
-            return `Error executing tool ${name}: ${error}`;
+        throw new Error('Attachment must provide base64, filePath, or url');
+    }
+    async resolveMimeType(mimeType, filePath, url) {
+        if (mimeType) {
+            return mimeType;
         }
+        const source = (filePath ?? url ?? '').toLowerCase();
+        if (source.endsWith('.png'))
+            return 'image/png';
+        if (source.endsWith('.jpg') || source.endsWith('.jpeg'))
+            return 'image/jpeg';
+        if (source.endsWith('.gif'))
+            return 'image/gif';
+        if (source.endsWith('.webp'))
+            return 'image/webp';
+        if (source.endsWith('.bmp'))
+            return 'image/bmp';
+        return undefined;
     }
-    /**
-     * Extract cost information from Claude usage object.
-     */
-    extractCostFromUsage(usage, modelId) {
-        const model = this.models.find(m => m.modelId === modelId);
+    translateSdkMessage(args) {
+        const { runId, options, message, modelId, toolsByIndex, toolsById, } = args;
+        let textAccumulated = args.textAccumulated;
+        let thinkingAccumulated = args.thinkingAccumulated;
+        let turnIndex = args.turnIndex;
+        let sessionId = args.sessionId;
+        const events = [];
+        if (message.type === 'system' && message.subtype === 'init') {
+            sessionId = message.session_id;
+            events.push({
+                ...this.createBaseEvent('session_start', runId),
+                type: 'session_start',
+                sessionId,
+                resumed: Boolean(options.sessionId),
+                forkedFrom: options.forkSessionId,
+            });
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'system' && message.subtype === 'session_state_changed') {
+            if (message.state === 'running') {
+                textAccumulated = '';
+                thinkingAccumulated = '';
+                turnIndex += 1;
+                events.push({
+                    ...this.createBaseEvent('turn_start', runId),
+                    type: 'turn_start',
+                    turnIndex,
+                });
+            }
+            else if (message.state === 'idle' && turnIndex >= 0) {
+                if (thinkingAccumulated.length > 0) {
+                    events.push({
+                        ...this.createBaseEvent('thinking_stop', runId),
+                        type: 'thinking_stop',
+                        thinking: thinkingAccumulated,
+                    });
+                    thinkingAccumulated = '';
+                }
+                if (textAccumulated.length > 0) {
+                    events.push(this.createMessageStopEvent(runId, textAccumulated));
+                    textAccumulated = '';
+                }
+                events.push({
+                    ...this.createBaseEvent('turn_end', runId),
+                    type: 'turn_end',
+                    turnIndex,
+                });
+            }
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'stream_event') {
+            const event = message.event;
+            if (event.type === 'message_start') {
+                events.push({
+                    ...this.createBaseEvent('message_start', runId),
+                    type: 'message_start',
+                });
+            }
+            if (event.type === 'content_block_start' && event.content_block) {
+                const contentBlock = event.content_block;
+                if (contentBlock.type === 'tool_use' || contentBlock.type === 'server_tool_use' || contentBlock.type === 'mcp_tool_use') {
+                    const id = String(contentBlock.id ?? `tool-${event.index}`);
+                    const state = {
+                        id,
+                        name: String(contentBlock.name ?? 'tool'),
+                        rawInput: contentBlock.input ? JSON.stringify(contentBlock.input) : '',
+                    };
+                    toolsByIndex.set(Number(event.index ?? 0), state);
+                    toolsById.set(id, state);
+                    events.push(this.createToolCallStartEvent(runId, id, state.name, state.rawInput));
+                }
+                else if (contentBlock.type === 'thinking') {
+                    events.push({
+                        ...this.createBaseEvent('thinking_start', runId),
+                        type: 'thinking_start',
+                    });
+                }
+            }
+            if (event.type === 'content_block_delta' && event.delta) {
+                const delta = event.delta;
+                if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+                    textAccumulated += delta.text;
+                    events.push(this.createTextDeltaEvent(runId, delta.text, textAccumulated));
+                }
+                else if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+                    thinkingAccumulated += delta.thinking;
+                    events.push({
+                        ...this.createBaseEvent('thinking_delta', runId),
+                        type: 'thinking_delta',
+                        delta: delta.thinking,
+                        accumulated: thinkingAccumulated,
+                    });
+                }
+                else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+                    const state = toolsByIndex.get(Number(event.index ?? 0));
+                    if (state) {
+                        state.rawInput += delta.partial_json;
+                        events.push({
+                            ...this.createBaseEvent('tool_input_delta', runId),
+                            type: 'tool_input_delta',
+                            toolCallId: state.id,
+                            delta: delta.partial_json,
+                            inputAccumulated: state.rawInput,
+                        });
+                    }
+                }
+            }
+            if (event.type === 'content_block_stop') {
+                const state = toolsByIndex.get(Number(event.index ?? 0));
+                if (state) {
+                    events.push({
+                        ...this.createBaseEvent('tool_call_ready', runId),
+                        type: 'tool_call_ready',
+                        toolCallId: state.id,
+                        toolName: state.name,
+                        input: this.parseToolInput(state.rawInput),
+                    });
+                }
+            }
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'user' && message.parent_tool_use_id && message.tool_use_result !== undefined) {
+            const toolState = toolsById.get(message.parent_tool_use_id);
+            events.push(this.createToolResultEvent(runId, message.parent_tool_use_id, toolState?.name ?? 'tool', message.tool_use_result));
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'result') {
+            const cost = this.extractCostFromResult(message, modelId);
+            if (cost) {
+                events.push(this.createCostEvent(runId, cost));
+            }
+            if (message.is_error) {
+                events.push(this.createErrorEvent(runId, 'INTERNAL', message.subtype === 'success' ? 'Claude Agent SDK returned an error result' : message.errors.join('; ') || message.subtype, false));
+            }
+            events.push(this.createMessageStopEvent(runId, message.subtype === 'success' ? message.result : textAccumulated));
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'system' && message.subtype === 'notification') {
+            events.push({
+                ...this.createBaseEvent('debug', runId),
+                type: 'debug',
+                level: 'info',
+                message: message.text,
+            });
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        if (message.type === 'system' && message.subtype === 'local_command_output') {
+            events.push(this.createTextDeltaEvent(runId, `${message.content}\n`, textAccumulated + `${message.content}\n`));
+            textAccumulated += `${message.content}\n`;
+            return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+        }
+        return { events, textAccumulated, thinkingAccumulated, turnIndex, sessionId };
+    }
+    parseToolInput(rawInput) {
+        if (!rawInput) {
+            return {};
+        }
+        try {
+            return JSON.parse(rawInput);
+        }
+        catch {
+            return rawInput;
+        }
+    }
+    extractCostFromResult(result, modelId) {
+        const model = this.models.find((candidate) => candidate.modelId === modelId);
         if (!model) {
-            return {
-                totalUsd: 0,
-                inputTokens: usage.input_tokens,
-                outputTokens: usage.output_tokens,
-            };
+            return null;
         }
-        const inputCost = (usage.input_tokens / 1_000_000) * model.inputPricePerMillion;
-        const outputCost = (usage.output_tokens / 1_000_000) * model.outputPricePerMillion;
-        const totalCost = inputCost + outputCost;
+        const usage = result.usage;
+        const inputTokens = typeof usage?.input_tokens === 'number' ? usage.input_tokens : 0;
+        const outputTokens = typeof usage?.output_tokens === 'number' ? usage.output_tokens : 0;
+        const cachedTokens = typeof usage?.cache_read_input_tokens === 'number' ? usage.cache_read_input_tokens : 0;
+        const thinkingTokens = typeof usage?.server_tool_use === 'number' ? usage.server_tool_use : 0;
         return {
-            totalUsd: totalCost,
-            inputTokens: usage.input_tokens,
-            outputTokens: usage.output_tokens,
+            totalUsd: result.total_cost_usd ?? ((inputTokens / 1_000_000) * (model.inputPricePerMillion ?? 0) +
+                (outputTokens / 1_000_000) * (model.outputPricePerMillion ?? 0)),
+            inputTokens,
+            outputTokens,
+            cachedTokens,
+            thinkingTokens,
         };
     }
 }