@agent-spaces/server 0.1.0

package/dist/adapters/agent-runtime-types.js

@@ -0,0 +1,7 @@
+export function summarizeResult(text) {
+    const normalized = text.trim().replace(/\s+/g, ' ');
+    if (!normalized)
+        return 'Completed agent execution';
+    return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
+}
+//# sourceMappingURL=agent-runtime-types.js.map

package/dist/adapters/agent-runtime.js

@@ -0,0 +1,23 @@
+/**
+ * Agent runtime adapter interface and factory.
+ */
+import { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
+import { CodexRuntime } from './codex-runtime.js';
+import { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
+export { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
+export { CodexRuntime } from './codex-runtime.js';
+export { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
+export function createAgentRuntime(configOrProvider = {}, model) {
+    const config = typeof configOrProvider === 'string'
+        ? { provider: configOrProvider, model }
+        : configOrProvider;
+    switch (config.kind ?? 'open-agent-sdk') {
+        case 'open-agent-sdk':
+            return new OpenAgentSdkRuntime(config);
+        case 'claude-code':
+            return new ClaudeCodeRuntime(config);
+        case 'codex':
+            return new CodexRuntime(config);
+    }
+}
+//# sourceMappingURL=agent-runtime.js.map

package/dist/adapters/claude-code-runtime/adapter-pool.js

@@ -0,0 +1,62 @@
+import { isAnthropicBridgeProvider, formatBridgeProvider } from './types.js';
+import { createAnthropicBridgeServer, findAvailablePort, listen, closeServer } from './anthropic-bridge.js';
+const activeClaudeAdapters = new Map();
+export async function startClaudeAdapterIfNeeded(config) {
+    if (!isAnthropicBridgeProvider(config.provider))
+        return null;
+    const adapterBaseURL = config.adapterBaseURL?.trim() || config.baseURL?.trim();
+    if (!adapterBaseURL)
+        throw new Error(`apiBase is required for ${formatBridgeProvider(config.provider)}`);
+    if (!config.apiKey?.trim())
+        throw new Error(`apiKey is required for ${formatBridgeProvider(config.provider)}`);
+    if (!config.model?.trim())
+        throw new Error(`modelId is required for ${formatBridgeProvider(config.provider)}`);
+    const adapterConfig = {
+        provider: config.provider,
+        baseUrl: adapterBaseURL,
+        apiKey: config.apiKey,
+        model: config.model,
+        thinkingEnabled: config.thinkingEnabled,
+        thinkingEffort: config.thinkingEffort,
+    };
+    const key = JSON.stringify(adapterConfig);
+    const existing = activeClaudeAdapters.get(key);
+    if (existing) {
+        existing.refs += 1;
+        return {
+            url: existing.url,
+            release: () => releaseClaudeAdapter(existing.key),
+        };
+    }
+    const server = createAnthropicBridgeServer(adapterConfig);
+    const port = await findAvailablePort(3080);
+    const url = await listen(server, port);
+    const adapter = {
+        key,
+        server,
+        url,
+        refs: 1,
+    };
+    activeClaudeAdapters.set(key, adapter);
+    return {
+        url,
+        release: () => releaseClaudeAdapter(key),
+    };
+}
+async function releaseClaudeAdapter(key) {
+    const adapter = activeClaudeAdapters.get(key);
+    if (!adapter)
+        return;
+    adapter.refs -= 1;
+    if (adapter.refs > 0)
+        return;
+    activeClaudeAdapters.delete(key);
+    await closeServer(adapter.server);
+}
+export function getClaudeCodeModel(config) {
+    if (isAnthropicBridgeProvider(config.provider)) {
+        return process.env.CLAUDE_CODE_MODEL || undefined;
+    }
+    return config.model;
+}
+//# sourceMappingURL=adapter-pool.js.map

package/dist/adapters/claude-code-runtime/anthropic-bridge.js

@@ -0,0 +1,209 @@
+import { createServer as createHttpServer } from 'node:http';
+import { createServer as createNetServer } from 'node:net';
+import { formatBridgeProvider } from './types.js';
+import { convertAnthropicToOpenAI, convertOpenAIChatRequestToResponses, convertResponsesToAnthropic, convertChatCompletionsToAnthropic } from './protocol-converter.js';
+import { truncate } from './message-format.js';
+export function createAnthropicBridgeServer(config) {
+    return createHttpServer((req, res) => {
+        void handleAnthropicBridgeRequest(req, res, config);
+    });
+}
+export function listen(server, port) {
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '0.0.0.0', () => {
+            server.off('error', reject);
+            resolve(`http://localhost:${port}`);
+        });
+    });
+}
+export async function findAvailablePort(preferredPort) {
+    return new Promise((resolve) => {
+        const server = createNetServer();
+        server.listen(preferredPort, () => {
+            const address = server.address();
+            const port = address?.port ?? preferredPort;
+            server.close(() => resolve(port));
+        });
+        server.on('error', () => {
+            resolve(findAvailablePort(preferredPort + 1));
+        });
+    });
+}
+export function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+    });
+}
+async function handleAnthropicBridgeRequest(req, res, config) {
+    const pathname = new URL(req.url ?? '/', 'http://localhost').pathname;
+    if (req.method === 'GET' && pathname === '/health') {
+        sendJson(res, 200, { status: 'ok', adapter: config.provider });
+        return;
+    }
+    if (req.method === 'OPTIONS') {
+        addCorsHeaders(res);
+        res.writeHead(200);
+        res.end();
+        return;
+    }
+    if (req.method !== 'POST' || pathname !== '/v1/messages') {
+        sendJson(res, 404, { error: { type: 'not_found_error', message: 'Not found' } });
+        return;
+    }
+    try {
+        const anthropicRequest = await readJson(req);
+        const openAIRequest = convertAnthropicToOpenAI(anthropicRequest, config.model, {
+            thinkingEnabled: config.thinkingEnabled,
+            thinkingEffort: config.thinkingEffort,
+        });
+        const requestBody = config.provider === 'openai-responses-to-anthropic-messages'
+            ? convertOpenAIChatRequestToResponses(openAIRequest)
+            : openAIRequest;
+        const upstreamPath = config.provider === 'openai-responses-to-anthropic-messages'
+            ? '/responses'
+            : '/chat/completions';
+        console.info('[anthropic-bridge] request', {
+            provider: config.provider,
+            sourceModel: anthropicRequest.model,
+            targetModel: config.model,
+            stream: Boolean(anthropicRequest.stream),
+            inputItems: Array.isArray(requestBody.input) ? requestBody.input.length : undefined,
+            messages: Array.isArray(requestBody.messages) ? requestBody.messages.length : undefined,
+            tools: Array.isArray(requestBody.tools) ? requestBody.tools.length : 0,
+        });
+        const upstream = await fetch(joinUrl(config.baseUrl, upstreamPath), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!upstream.ok) {
+            const text = await upstream.text();
+            console.warn('[anthropic-bridge] upstream failed', {
+                provider: config.provider,
+                status: upstream.status,
+                targetModel: config.model,
+                body: truncate(text, 2000),
+            });
+            sendJson(res, upstream.status, {
+                error: {
+                    type: upstream.status >= 500 ? 'api_error' : 'invalid_request_error',
+                    message: text || `${formatBridgeProvider(config.provider)} request failed with status ${upstream.status}`,
+                },
+            });
+            return;
+        }
+        const upstreamBody = await upstream.json();
+        console.info('[anthropic-bridge] upstream succeeded', {
+            provider: config.provider,
+            targetModel: config.model,
+            responseId: upstreamBody.id,
+            outputItems: 'output' in upstreamBody ? upstreamBody.output?.length ?? 0 : undefined,
+            choices: 'choices' in upstreamBody ? upstreamBody.choices?.length ?? 0 : undefined,
+        });
+        const anthropicResponse = config.provider === 'openai-responses-to-anthropic-messages'
+            ? convertResponsesToAnthropic(upstreamBody, anthropicRequest.model)
+            : convertChatCompletionsToAnthropic(upstreamBody, anthropicRequest.model);
+        if (anthropicRequest.stream) {
+            sendAnthropicStream(res, anthropicResponse);
+            return;
+        }
+        sendJson(res, 200, anthropicResponse);
+    }
+    catch (err) {
+        console.error('[anthropic-bridge] proxy failed', err);
+        sendJson(res, 500, {
+            error: {
+                type: 'api_error',
+                message: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
+function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, '')}${path}`;
+}
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+}
+function addCorsHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, anthropic-version, x-api-key');
+}
+function sendJson(res, status, body) {
+    addCorsHeaders(res);
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+function sendAnthropicStream(res, message) {
+    addCorsHeaders(res);
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    const content = Array.isArray(message.content) ? message.content : [];
+    sendSse(res, 'message_start', {
+        type: 'message_start',
+        message: {
+            ...message,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+        },
+    });
+    content.forEach((block, index) => {
+        sendSse(res, 'content_block_start', {
+            type: 'content_block_start',
+            index,
+            content_block: block.type === 'text' ? { type: 'text', text: '' } : { ...block, input: {} },
+        });
+        if (block.type === 'text') {
+            sendSse(res, 'content_block_delta', {
+                type: 'content_block_delta',
+                index,
+                delta: { type: 'text_delta', text: String(block.text ?? '') },
+            });
+        }
+        else if (block.type === 'tool_use') {
+            sendSse(res, 'content_block_delta', {
+                type: 'content_block_delta',
+                index,
+                delta: { type: 'input_json_delta', partial_json: JSON.stringify(block.input ?? {}) },
+            });
+        }
+        sendSse(res, 'content_block_stop', {
+            type: 'content_block_stop',
+            index,
+        });
+    });
+    const usage = message.usage && typeof message.usage === 'object'
+        ? message.usage
+        : {};
+    sendSse(res, 'message_delta', {
+        type: 'message_delta',
+        delta: {
+            stop_reason: message.stop_reason ?? 'end_turn',
+            stop_sequence: null,
+        },
+        usage: {
+            output_tokens: usage.output_tokens ?? 0,
+        },
+    });
+    sendSse(res, 'message_stop', { type: 'message_stop' });
+    res.end();
+}
+function sendSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+//# sourceMappingURL=anthropic-bridge.js.map

package/dist/adapters/claude-code-runtime/index.js

@@ -0,0 +1,195 @@
+import { join } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { summarizeResult } from '../agent-runtime-types.js';
+import { normalizeAdditionalDirectories, normalizePermissionMode, normalizeSkillNames, prepareConfigDir, resolveBundledClaudeExecutable, buildEnv, normalizeMcpServers } from './sdk-config.js';
+import { startClaudeAdapterIfNeeded, getClaudeCodeModel } from './adapter-pool.js';
+import { extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
+export class ClaudeCodeRuntime {
+    config;
+    abortController = null;
+    activeQuery = null;
+    adapterRun = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async execute(prompt, workingDir, options) {
+        this.abortController = new AbortController();
+        const output = [];
+        const cwd = workingDir || process.cwd();
+        const startTime = Date.now();
+        const MAX_LOG = 500;
+        const d = (msg) => console.log(`[claude-code] ${msg.length > MAX_LOG ? msg.slice(0, MAX_LOG) + '...' : msg}`);
+        const permissionMode = normalizePermissionMode(this.config.permissionMode);
+        const agentDir = options?.configDir;
+        const configDir = agentDir ? join(agentDir, '.claude') : undefined;
+        if (configDir)
+            prepareConfigDir(configDir, agentDir);
+        const skillNames = normalizeSkillNames(options?.skills, configDir);
+        const claudeExecutable = resolveBundledClaudeExecutable();
+        this.adapterRun = await startClaudeAdapterIfNeeded(this.config);
+        const baseURL = this.adapterRun?.url ?? this.config.baseURL;
+        const apiKey = this.adapterRun ? 'default' : this.config.apiKey;
+        const model = getClaudeCodeModel(this.config);
+        const additionalDirectories = normalizeAdditionalDirectories(cwd, options?.sandboxDirs);
+        d(`starting | cwd=${cwd} model=${model ?? 'default'} targetModel=${this.config.model ?? 'default'} provider=${this.config.provider ?? 'default'} baseURL=${baseURL ?? 'default'} permissionMode=${permissionMode} maxTurns=${options?.maxTurns ?? '∞'} tools=claude_code mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillNames.join(',') || '-'} configDir=${configDir ?? 'default'} sandboxDirs=${additionalDirectories.join(',') || '-'} claudeExecutable=${claudeExecutable ?? 'sdk-default'}`);
+        d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
+        try {
+            const queryOptions = {
+                cwd,
+                model,
+                maxTurns: options?.maxTurns,
+                pathToClaudeCodeExecutable: claudeExecutable,
+                tools: { type: 'preset', preset: 'claude_code' },
+                mcpServers: normalizeMcpServers(options?.mcpServers, options?.functionTools),
+                skills: skillNames,
+                managedSettings: {
+                    strictPluginOnlyCustomization: ['mcp'],
+                },
+                settingSources: [],
+                strictMcpConfig: true,
+                additionalDirectories,
+                permissionMode,
+                allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions' ? true : undefined,
+                abortController: this.abortController,
+                env: buildEnv(this.config, configDir, { baseURL, apiKey }),
+                stderr: (data) => {
+                    const line = data.trim();
+                    if (line)
+                        d(`stderr: ${line}`);
+                },
+            };
+            this.activeQuery = query({ prompt, options: queryOptions });
+            let resultText = '';
+            let turns = 0;
+            let tokenCount = 0;
+            let error;
+            let usageLine = null;
+            let usage;
+            let costUsd;
+            const pendingAskUserQuestionToolIds = new Set();
+            let waitingForUserAnswer = false;
+            for await (const message of this.activeQuery) {
+                const toolUses = extractToolUseEvents(message);
+                for (const toolUse of toolUses) {
+                    if (toolUse.name === 'AskUserQuestion') {
+                        pendingAskUserQuestionToolIds.add(toolUse.id);
+                    }
+                }
+                const toolResult = extractToolResultEvent(message);
+                const suppressAskUserQuestionResult = Boolean(toolResult
+                    && isAskUserQuestionAutoResult(toolResult.result)
+                    && (pendingAskUserQuestionToolIds.size > 0
+                        || (toolResult.toolUseId ? pendingAskUserQuestionToolIds.has(toolResult.toolUseId) : false)));
+                if (suppressAskUserQuestionResult) {
+                    waitingForUserAnswer = true;
+                }
+                logToolDebug(message, d, { suppressAskUserQuestionResult });
+                for (const text of extractThinkingEvents(message)) {
+                    d(`thinking | ${text}`);
+                    options?.onEvent?.({ type: 'reasoning', text, status: 'completed' });
+                }
+                for (const toolUse of toolUses) {
+                    options?.onEvent?.({ type: 'tool_use', ...toolUse });
+                }
+                if (toolResult && !suppressAskUserQuestionResult) {
+                    options?.onEvent?.({ type: 'tool_result', ...toolResult });
+                }
+                const line = formatMessage(message);
+                if (line && !isAskUserQuestionAutoResult(line)) {
+                    if (message.type === 'assistant') {
+                        d(`assistant | ${line}`);
+                    }
+                    output.push(line);
+                    options?.onEvent?.({ type: 'output', line });
+                }
+                if (message.type === 'result') {
+                    turns = message.num_turns;
+                    tokenCount = countUsageTokens(message.usage);
+                    usageLine = formatUsageLine(message.usage);
+                    usage = normalizeUsage(message.usage);
+                    costUsd = readTotalCostUsd(message);
+                    if (message.subtype === 'success') {
+                        if (!isAskUserQuestionAutoResult(message.result)) {
+                            resultText = message.result;
+                        }
+                    }
+                    else {
+                        error = message.errors.join('\n') || message.subtype;
+                    }
+                }
+            }
+            const elapsed = Date.now() - startTime;
+            if (waitingForUserAnswer && (!error || isAskUserQuestionAutoResult(error))) {
+                d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                if (usageLine)
+                    output.push(usageLine);
+                return {
+                    success: true,
+                    summary: 'Waiting for user answer',
+                    artifacts: [],
+                    output,
+                    usage,
+                    costUsd,
+                };
+            }
+            if (error) {
+                d(`failed ${elapsed}ms | turns=${turns} tokens=${tokenCount} | ${error}`);
+                if (usageLine)
+                    output.push(usageLine);
+                return {
+                    success: false,
+                    summary: 'Claude Code execution failed',
+                    artifacts: [],
+                    error,
+                    output,
+                    usage,
+                    costUsd,
+                };
+            }
+            const text = resultText || output.at(-1) || '';
+            if (text.trim()) {
+                d(`final message | ${text.trim()}`);
+            }
+            d(`done ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+            const finalOutput = resultText && !output.includes(resultText) ? [...output, resultText] : output;
+            if (usageLine && !finalOutput.includes(usageLine))
+                finalOutput.push(usageLine);
+            return {
+                success: true,
+                summary: summarizeResult(text),
+                artifacts: [],
+                output: finalOutput,
+                usage,
+                costUsd,
+            };
+        }
+        catch (err) {
+            const elapsed = Date.now() - startTime;
+            const message = err instanceof Error ? err.message : String(err);
+            d(`failed ${elapsed}ms | ${message}`);
+            if (err instanceof Error && err.stack)
+                console.error(err.stack);
+            return { success: false, summary: 'Claude Code execution failed', artifacts: [], error: message, output };
+        }
+        finally {
+            this.activeQuery?.close();
+            this.activeQuery = null;
+            await this.adapterRun?.release();
+            this.adapterRun = null;
+            this.abortController = null;
+        }
+    }
+    stop() {
+        this.abortController?.abort();
+        void this.activeQuery?.interrupt().catch(() => {
+            this.activeQuery?.close();
+        });
+    }
+}
+function readTotalCostUsd(message) {
+    if (!message || typeof message !== 'object')
+        return undefined;
+    const value = message.total_cost_usd;
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=index.js.map