@agent-spaces/server 0.1.0

package/dist/adapters/claude-code-runtime/message-format.js

@@ -0,0 +1,241 @@
+export function formatMessage(message) {
+    switch (message.type) {
+        case 'assistant':
+            return formatAssistantMessage(message.message.content);
+        case 'result':
+            return message.subtype === 'success' ? message.result : message.errors.join('\n');
+        case 'system':
+            if (message.subtype === 'init') {
+                return `Claude Code initialized with ${message.model}`;
+            }
+            if (message.subtype === 'task_started') {
+                return message.description;
+            }
+            if (message.subtype === 'task_progress') {
+                return message.summary || message.description;
+            }
+            if (message.subtype === 'task_notification') {
+                return message.summary;
+            }
+            if (message.subtype === 'local_command_output') {
+                return message.content;
+            }
+            return null;
+        case 'tool_progress':
+            return `${message.tool_name} running (${message.elapsed_time_seconds}s)`;
+        case 'tool_use_summary':
+            return message.summary;
+        default:
+            return null;
+    }
+}
+function formatAssistantMessage(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = content.flatMap((block) => {
+        if (!block || typeof block !== 'object')
+            return [];
+        const typedBlock = block;
+        if (typedBlock.type === 'text' && typeof typedBlock.text === 'string') {
+            return [typedBlock.text];
+        }
+        return [];
+    });
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+export function extractThinkingEvents(message) {
+    if (message.type !== 'assistant' || !Array.isArray(message.message.content))
+        return [];
+    return message.message.content.flatMap((block) => {
+        if (!block || typeof block !== 'object')
+            return [];
+        const typedBlock = block;
+        if (typedBlock.type !== 'thinking' || typeof typedBlock.thinking !== 'string')
+            return [];
+        const text = typedBlock.thinking.trim();
+        return text ? [text] : [];
+    });
+}
+export function extractToolUseEvents(message) {
+    if (message.type !== 'assistant' || !Array.isArray(message.message.content))
+        return [];
+    return message.message.content.flatMap((block) => {
+        if (!block || typeof block !== 'object')
+            return [];
+        const typedBlock = block;
+        if (typedBlock.type !== 'tool_use' || typeof typedBlock.name !== 'string')
+            return [];
+        return [{
+                id: typeof typedBlock.id === 'string' ? typedBlock.id : typedBlock.name,
+                name: typedBlock.name,
+                input: typedBlock.input,
+                line: formatToolUse(typedBlock.name, typedBlock.input),
+            }];
+    });
+}
+export function extractToolResultEvent(message) {
+    if (message.type !== 'user')
+        return null;
+    const parentToolUseId = message.parent_tool_use_id;
+    const toolUseId = typeof parentToolUseId === 'string' && parentToolUseId ? parentToolUseId : undefined;
+    const directResult = message.tool_use_result;
+    if (directResult !== undefined) {
+        return { toolUseId, result: directResult };
+    }
+    const content = message.message?.content;
+    if (Array.isArray(content)) {
+        const toolResultBlock = content.find((block) => {
+            return Boolean(block && typeof block === 'object' && block.type === 'tool_result');
+        });
+        if (toolResultBlock) {
+            return { toolUseId, result: toolResultBlock.content };
+        }
+    }
+    return null;
+}
+export function logToolDebug(message, d, options = {}) {
+    switch (message.type) {
+        case 'assistant':
+            logAssistantToolUses(message.message.content, d);
+            return;
+        case 'user': {
+            const toolResult = message.tool_use_result;
+            if (toolResult !== undefined) {
+                if (options.suppressAskUserQuestionResult)
+                    return;
+                d(`tool result | parent=${message.parent_tool_use_id ?? '-'} result=${summarizeToolResult(toolResult)}`);
+            }
+            return;
+        }
+        case 'tool_progress':
+            d(`tool progress | id=${message.tool_use_id} name=${message.tool_name} elapsed=${message.elapsed_time_seconds}s parent=${message.parent_tool_use_id ?? '-'}`);
+            return;
+        case 'tool_use_summary':
+            d(`tool summary | ids=${message.preceding_tool_use_ids.join(',') || '-'} summary=${truncate(message.summary, 240)}`);
+            return;
+        case 'system':
+            if (message.subtype === 'task_started') {
+                d(`subagent started | ${truncate(message.description, 240)}`);
+            }
+            else if (message.subtype === 'task_progress') {
+                d(`subagent progress | ${truncate(message.summary || message.description, 240)}`);
+            }
+            else if (message.subtype === 'task_notification') {
+                d(`subagent notification | ${truncate(message.summary, 240)}`);
+            }
+            else if (message.subtype === 'local_command_output') {
+                d(`local command output | ${truncate(message.content, 240)}`);
+            }
+            return;
+        default:
+            return;
+    }
+}
+function logAssistantToolUses(content, d) {
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const typedBlock = block;
+        if (typedBlock.type !== 'tool_use' || typeof typedBlock.name !== 'string')
+            continue;
+        const id = typeof typedBlock.id === 'string' ? typedBlock.id : '-';
+        d(`tool use | id=${id} name=${typedBlock.name} input=${summarizeToolInput(typedBlock.input) || '-'}`);
+    }
+}
+function formatToolUse(name, input) {
+    const summary = summarizeToolInput(input);
+    return summary ? `Tool: ${name} ${summary}` : `Tool: ${name}`;
+}
+function summarizeToolInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return '';
+    const record = input;
+    const keys = ['file_path', 'path', 'command', 'pattern', 'query', 'description', 'prompt'];
+    const details = keys.flatMap((key) => {
+        const value = record[key];
+        if (typeof value !== 'string' || !value.trim())
+            return [];
+        return `${key}=${JSON.stringify(truncate(value.trim(), 140))}`;
+    });
+    if (details.length > 0)
+        return details.join(' ');
+    return JSON.stringify(redactLargeInput(record));
+}
+export function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max - 3)}...` : value;
+}
+function redactLargeInput(input) {
+    return Object.fromEntries(Object.entries(input).map(([key, value]) => {
+        if (typeof value === 'string')
+            return [key, truncate(value, 140)];
+        return [key, value];
+    }));
+}
+function summarizeToolResult(result) {
+    if (typeof result === 'string')
+        return JSON.stringify(truncate(result, 240));
+    if (!result || typeof result !== 'object')
+        return JSON.stringify(result);
+    return JSON.stringify(redactLargeInput(result));
+}
+export function isAskUserQuestionAutoResult(result) {
+    if (typeof result === 'string')
+        return /Answer questions\?/i.test(result);
+    if (!result || typeof result !== 'object')
+        return false;
+    return /Answer questions\?/i.test(JSON.stringify(result));
+}
+export function countUsageTokens(usage) {
+    if (!usage || typeof usage !== 'object')
+        return 0;
+    const values = Object.values(usage);
+    return values.reduce((total, value) => total + (typeof value === 'number' ? value : 0), 0);
+}
+export function formatUsageLine(usage) {
+    const normalized = normalizeClaudeUsage(usage);
+    if (!normalized)
+        return null;
+    return [
+        `[Usage] tokens=${normalized.totalTokens}`,
+        `input=${normalized.inputTokens}`,
+        `output=${normalized.outputTokens}`,
+        `cached=${normalized.cachedInputTokens}`,
+        `reasoning=${normalized.reasoningTokens}`,
+    ].join(' ');
+}
+export function normalizeUsage(usage) {
+    const normalized = normalizeClaudeUsage(usage);
+    if (!normalized)
+        return undefined;
+    return {
+        inputTokens: normalized.inputTokens,
+        outputTokens: normalized.outputTokens,
+        cachedInputTokens: normalized.cachedInputTokens,
+        reasoningTokens: normalized.reasoningTokens,
+        totalTokens: normalized.totalTokens,
+    };
+}
+function normalizeClaudeUsage(usage) {
+    if (!usage || typeof usage !== 'object')
+        return null;
+    const record = usage;
+    const inputTokens = numberValue(record.input_tokens);
+    const outputTokens = numberValue(record.output_tokens);
+    const cachedInputTokens = numberValue(record.cache_read_input_tokens)
+        + numberValue(record.cache_creation_input_tokens)
+        + numberValue(record.cached_input_tokens);
+    const reasoningTokens = numberValue(record.reasoning_output_tokens)
+        + numberValue(record.reasoning_tokens);
+    const totalTokens = inputTokens + outputTokens + cachedInputTokens + reasoningTokens;
+    if (totalTokens === 0)
+        return null;
+    return { inputTokens, outputTokens, cachedInputTokens, reasoningTokens, totalTokens };
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+//# sourceMappingURL=message-format.js.map

package/dist/adapters/claude-code-runtime/protocol-converter.js

@@ -0,0 +1,332 @@
+export function convertAnthropicToOpenAI(request, model, options = {}) {
+    const messages = [];
+    const system = normalizeSystemPrompt(request.system);
+    if (system)
+        messages.push({ role: 'system', content: system });
+    for (const message of request.messages) {
+        messages.push(...convertAnthropicMessage(message));
+    }
+    return compactObject({
+        model,
+        messages,
+        max_tokens: request.max_tokens === 1 ? 32 : request.max_tokens,
+        temperature: request.temperature,
+        top_p: request.top_p,
+        stop: request.stop_sequences,
+        reasoning: options.thinkingEnabled === false
+            ? undefined
+            : { effort: options.thinkingEffort ?? 'medium' },
+        tools: request.tools?.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+            },
+        })),
+        tool_choice: convertOpenAIToolChoice(request.tool_choice),
+    });
+}
+export function convertAnthropicMessage(message) {
+    if (typeof message.content === 'string') {
+        if (message.role === 'assistant' && isAssistantPrefill(message.content))
+            return [];
+        return [{ role: message.role, content: message.content }];
+    }
+    if (message.role === 'user') {
+        const output = [];
+        const textParts = [];
+        for (const block of message.content) {
+            if (block.type === 'text') {
+                textParts.push(block.text);
+                continue;
+            }
+            if (block.type === 'tool_result') {
+                output.push({
+                    role: 'tool',
+                    tool_call_id: block.tool_use_id,
+                    content: stringifyToolResult(block),
+                });
+            }
+        }
+        if (textParts.length > 0) {
+            output.push({ role: 'user', content: textParts.join('\n') });
+        }
+        return output;
+    }
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of message.content) {
+        if (block.type === 'text') {
+            textParts.push(block.text);
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            toolCalls.push({
+                id: block.id,
+                type: 'function',
+                function: {
+                    name: block.name,
+                    arguments: JSON.stringify(block.input ?? {}),
+                },
+            });
+        }
+    }
+    const content = textParts.join('\n');
+    if (toolCalls.length === 0 && isAssistantPrefill(content))
+        return [];
+    return [{
+            role: 'assistant',
+            content: content || null,
+            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        }];
+}
+export function convertOpenAIChatRequestToResponses(chatRequest) {
+    const messages = chatRequest.messages;
+    const instructions = messages
+        .filter((message) => message.role === 'system')
+        .map((message) => stringifyContent(message.content))
+        .filter(Boolean)
+        .join('\n\n');
+    const input = messages
+        .filter((message) => message.role !== 'system')
+        .flatMap(convertChatMessageToResponseInput);
+    return compactObject({
+        model: chatRequest.model,
+        input,
+        instructions: instructions || undefined,
+        max_output_tokens: chatRequest.max_tokens,
+        temperature: chatRequest.temperature,
+        top_p: chatRequest.top_p,
+        stop: chatRequest.stop,
+        reasoning: chatRequest.reasoning,
+        tools: chatRequest.tools?.map((tool) => ({
+            type: 'function',
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+            strict: false,
+        })),
+        tool_choice: convertResponsesToolChoice(chatRequest.tool_choice),
+    });
+}
+export function convertResponsesToAnthropic(response, originalModel) {
+    const content = extractResponsesContent(response);
+    const hasToolUse = content.some((block) => block.type === 'tool_use');
+    return {
+        id: `msg_${response.id ?? Date.now().toString(36)}`,
+        type: 'message',
+        role: 'assistant',
+        content: content.length ? content : [{ type: 'text', text: '' }],
+        model: originalModel,
+        stop_reason: hasToolUse ? 'tool_use' : 'end_turn',
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.input_tokens ?? 0,
+            output_tokens: response.usage?.output_tokens ?? 0,
+            cache_read_input_tokens: response.usage?.input_tokens_details?.cached_tokens,
+            reasoning_output_tokens: response.usage?.output_tokens_details?.reasoning_tokens,
+        },
+    };
+}
+export function convertChatCompletionsToAnthropic(response, originalModel) {
+    const choice = response.choices?.[0];
+    const message = choice?.message;
+    const content = [];
+    if (message?.content) {
+        content.push({ type: 'text', text: message.content });
+    }
+    for (const toolCall of message?.tool_calls ?? []) {
+        content.push({
+            type: 'tool_use',
+            id: String(toolCall.id ?? `call_${Date.now().toString(36)}`),
+            name: String(toolCall.function?.name ?? ''),
+            input: parseJsonObject(String(toolCall.function?.arguments ?? '{}')),
+        });
+    }
+    return {
+        id: `msg_${response.id ?? Date.now().toString(36)}`,
+        type: 'message',
+        role: 'assistant',
+        content: content.length ? content : [{ type: 'text', text: '' }],
+        model: originalModel,
+        stop_reason: mapOpenAIStopReason(choice?.finish_reason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0,
+            cache_read_input_tokens: response.usage?.prompt_tokens_details?.cached_tokens,
+            reasoning_output_tokens: response.usage?.completion_tokens_details?.reasoning_tokens,
+        },
+    };
+}
+function normalizeSystemPrompt(system) {
+    if (!system)
+        return '';
+    if (typeof system === 'string')
+        return system;
+    return system
+        .map((item) => typeof item.text === 'string' ? item.text : '')
+        .filter(Boolean)
+        .join('\n');
+}
+function stringifyToolResult(block) {
+    const content = typeof block.content === 'string'
+        ? block.content
+        : block.content
+            .map((item) => item.type === 'text' ? item.text : JSON.stringify(item))
+            .join('\n');
+    return block.is_error ? `Error: ${content}` : content;
+}
+function convertOpenAIToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (toolChoice.type === 'auto')
+        return 'auto';
+    if (toolChoice.type === 'any')
+        return 'required';
+    if (toolChoice.type === 'tool' && toolChoice.name) {
+        return { type: 'function', function: { name: toolChoice.name } };
+    }
+    return undefined;
+}
+function isAssistantPrefill(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return false;
+    return ['{', '[', '```', '{"', '[{', '<', '<tool_code', '<tool_code>'].includes(trimmed)
+        || trimmed.length <= 2
+        || (trimmed.startsWith('<tool_code') && !trimmed.includes('</tool_code>'));
+}
+function convertChatMessageToResponseInput(rawMessage) {
+    const message = rawMessage;
+    const role = message.role;
+    if (role === 'tool') {
+        return [{
+                type: 'function_call_output',
+                call_id: String(message.tool_call_id ?? ''),
+                output: String(message.content ?? ''),
+            }];
+    }
+    if (role === 'assistant' && Array.isArray(message.tool_calls)) {
+        const items = [];
+        const content = typeof message.content === 'string' ? message.content.trim() : '';
+        if (content)
+            items.push(createResponseMessage('assistant', content));
+        for (const toolCall of message.tool_calls) {
+            const fn = toolCall.function;
+            items.push({
+                type: 'function_call',
+                call_id: String(toolCall.id ?? ''),
+                name: String(fn?.name ?? ''),
+                arguments: String(fn?.arguments ?? '{}'),
+            });
+        }
+        return items;
+    }
+    if (role === 'system')
+        return [createResponseMessage('system', stringifyContent(message.content))];
+    if (role === 'assistant')
+        return [createResponseMessage('assistant', stringifyContent(message.content))];
+    return [createResponseMessage('user', stringifyContent(message.content))];
+}
+function createResponseMessage(role, text) {
+    return {
+        type: 'message',
+        role,
+        content: text,
+    };
+}
+function stringifyContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((part) => {
+        if (!part || typeof part !== 'object')
+            return '';
+        const record = part;
+        return typeof record.text === 'string' ? record.text : JSON.stringify(record);
+    }).filter(Boolean).join('\n');
+}
+function convertResponsesToolChoice(toolChoice) {
+    if (!toolChoice || toolChoice === 'auto' || toolChoice === 'none' || toolChoice === 'required')
+        return toolChoice;
+    if (typeof toolChoice !== 'object')
+        return undefined;
+    const fn = toolChoice.function;
+    return fn?.name ? { type: 'function', name: fn.name } : undefined;
+}
+function extractResponsesContent(response) {
+    const blocks = [];
+    if (response.output_text)
+        blocks.push({ type: 'text', text: response.output_text });
+    for (const item of response.output ?? []) {
+        if (item.type === 'message' && Array.isArray(item.content)) {
+            const text = item.content.map((part) => {
+                if (!part || typeof part !== 'object')
+                    return '';
+                const record = part;
+                return typeof record.text === 'string' ? record.text : '';
+            }).filter(Boolean).join('');
+            if (text && !blocks.some((block) => block.type === 'text' && block.text === text)) {
+                blocks.push({ type: 'text', text });
+            }
+            continue;
+        }
+        if (item.type === 'reasoning') {
+            const thinking = extractReasoningText(item);
+            if (thinking)
+                blocks.push({ type: 'thinking', thinking });
+            continue;
+        }
+        if (item.type === 'function_call') {
+            blocks.push({
+                type: 'tool_use',
+                id: String(item.call_id ?? item.id ?? `call_${Date.now().toString(36)}`),
+                name: String(item.name ?? ''),
+                input: parseJsonObject(String(item.arguments ?? '{}')),
+            });
+        }
+    }
+    return blocks;
+}
+function extractReasoningText(item) {
+    if (typeof item.summary === 'string')
+        return item.summary;
+    if (Array.isArray(item.summary)) {
+        return item.summary.map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (!part || typeof part !== 'object')
+                return '';
+            const record = part;
+            return typeof record.text === 'string' ? record.text : '';
+        }).filter(Boolean).join('\n');
+    }
+    if (typeof item.text === 'string')
+        return item.text;
+    if (typeof item.content === 'string')
+        return item.content;
+    return '';
+}
+function mapOpenAIStopReason(finishReason) {
+    if (finishReason === 'length')
+        return 'max_tokens';
+    if (finishReason === 'tool_calls')
+        return 'tool_use';
+    return 'end_turn';
+}
+export function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+//# sourceMappingURL=protocol-converter.js.map