salmon-loop 0.2.3

package/dist/cli/headless/native-stream-normalized-encoder.js

@@ -0,0 +1,206 @@
+import { encodeStreamEvent, encodeStreamFailure, } from './stream-json-protocol.js';
+export function encodeNormalizedToNativeStreamLines(params) {
+    const at = params.event.timestamp;
+    if (params.event.type === 'normalized.message_start') {
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: params.event.messageId,
+                        type: 'message',
+                        role: params.event.role,
+                        content: [],
+                    },
+                },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.content_block_start') {
+        if (params.event.blockType === 'text') {
+            return [
+                encodeStreamEvent({
+                    uuid: params.uuid(),
+                    sessionId: params.sessionId,
+                    at,
+                    event: {
+                        type: 'content_block_start',
+                        index: params.event.index,
+                        content_block: { type: 'text', text: '' },
+                    },
+                }),
+            ];
+        }
+        // Tool blocks are derived from normalized.tool_request_* and normalized.tool_call_end events.
+        return [];
+    }
+    if (params.event.type === 'normalized.content_block_delta') {
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                event: {
+                    type: 'content_block_delta',
+                    index: params.event.index,
+                    delta: { type: 'text_delta', text: params.event.text },
+                },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.content_block_end') {
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                event: { type: 'content_block_stop', index: params.event.index },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.message_end') {
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                event: { type: 'message_stop', stop_reason: params.event.finishReason ?? 'end_turn' },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.tool_request_start') {
+        const parentToolUseId = params.event.callId;
+        const phase = params.event.phase;
+        const round = params.event.round;
+        const input = {};
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: `tool_use:${parentToolUseId}`,
+                        type: 'message',
+                        role: 'assistant',
+                        content: [],
+                    },
+                },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'tool_use',
+                        id: parentToolUseId,
+                        name: params.event.toolName,
+                        input,
+                        meta: { phase, round },
+                    },
+                },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: { type: 'content_block_stop', index: 0 },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: { type: 'message_stop', stop_reason: 'tool_use' },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.tool_call_end') {
+        const parentToolUseId = params.event.callId;
+        const phase = params.event.phase;
+        const round = params.event.round;
+        const isError = params.event.status !== 'ok';
+        const summaryParts = [];
+        summaryParts.push(`tool=${params.event.toolName}`);
+        summaryParts.push(`status=${params.event.status}`);
+        if (typeof params.event.durationMs === 'number') {
+            summaryParts.push(`duration_ms=${params.event.durationMs}`);
+        }
+        if (params.event.errorCode)
+            summaryParts.push(`error_code=${params.event.errorCode}`);
+        let content = summaryParts.join(' ');
+        if (params.event.outputSummary)
+            content += `\noutput_summary=${params.event.outputSummary}`;
+        return [
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: `tool_result:${parentToolUseId}`,
+                        type: 'message',
+                        role: 'user',
+                        content: [],
+                    },
+                },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'tool_result',
+                        tool_use_id: parentToolUseId,
+                        is_error: isError,
+                        content,
+                        meta: { phase, round },
+                    },
+                },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: { type: 'content_block_stop', index: 0 },
+            }),
+            encodeStreamEvent({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                parentToolUseId,
+                event: { type: 'message_stop', stop_reason: 'end_turn' },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.error') {
+        return [
+            encodeStreamFailure({
+                uuid: params.uuid(),
+                sessionId: params.sessionId,
+                at,
+                message: params.event.message,
+                name: params.event.code,
+            }),
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=native-stream-normalized-encoder.js.map

package/dist/cli/headless/openai-responses-canonical-applier.js

@@ -0,0 +1,94 @@
+import { parseCanonicalFunctionCallItemId, } from '../../core/facades/cli-headless.js';
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object';
+}
+function getString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : null;
+}
+export class OpenAiResponsesCanonicalApplier {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    apply(params) {
+        const { streamId, event } = params;
+        switch (event.type) {
+            case 'response.output_item.added': {
+                if (!isRecord(event))
+                    return [];
+                const itemUnknown = event.item;
+                if (!isRecord(itemUnknown))
+                    return [];
+                const itemType = getString(itemUnknown, 'type');
+                if (itemType === 'function_call') {
+                    const callId = getString(itemUnknown, 'call_id');
+                    const toolName = getString(itemUnknown, 'name');
+                    if (!callId || !toolName)
+                        return [];
+                    const itemId = getString(itemUnknown, 'id') ?? undefined;
+                    return this.state.startFunctionCall(callId, toolName, itemId);
+                }
+                if (itemType === 'message') {
+                    const itemId = getString(itemUnknown, 'id') ?? undefined;
+                    return this.state.ensureAssistantMessage(streamId, itemId);
+                }
+                return [];
+            }
+            case 'response.function_call_arguments.delta': {
+                const callId = parseCanonicalFunctionCallItemId(event.item_id);
+                if (!callId)
+                    return [];
+                if (typeof event.delta !== 'string')
+                    return [];
+                return this.state.appendFunctionCallArgs(callId, event.delta);
+            }
+            case 'response.function_call_arguments.done': {
+                const callId = parseCanonicalFunctionCallItemId(event.item_id);
+                if (!callId)
+                    return [];
+                if (typeof event.arguments !== 'string')
+                    return [];
+                const name = typeof event.name === 'string' ? event.name : undefined;
+                return this.state.finishFunctionCallArgs(callId, event.arguments, name);
+            }
+            case 'response.output_item.done': {
+                if (!isRecord(event))
+                    return [];
+                const itemUnknown = event.item;
+                if (!isRecord(itemUnknown))
+                    return [];
+                const itemType = getString(itemUnknown, 'type');
+                if (itemType === 'function_call') {
+                    const callId = getString(itemUnknown, 'call_id');
+                    const args = getString(itemUnknown, 'arguments');
+                    if (!callId || args === null)
+                        return [];
+                    return this.state.finishFunctionCall(callId, args);
+                }
+                if (itemType === 'message')
+                    return this.state.doneMessageItem(streamId);
+                return [];
+            }
+            case 'response.content_part.added': {
+                return this.state.ensureTextPart(streamId);
+            }
+            case 'response.output_text.delta': {
+                if (typeof event.delta !== 'string')
+                    return [];
+                return this.state.appendTextDelta(streamId, event.delta);
+            }
+            case 'response.output_text.done': {
+                const text = isRecord(event) && typeof event.text === 'string' ? event.text : undefined;
+                return this.state.doneOutputText(streamId, text);
+            }
+            case 'response.content_part.done': {
+                return this.state.doneContentPart(streamId);
+            }
+            default: {
+                return [];
+            }
+        }
+    }
+}
+//# sourceMappingURL=openai-responses-canonical-applier.js.map

package/dist/cli/headless/openai-responses-state.js

@@ -0,0 +1,294 @@
+function cloneOutputTextPart(part) {
+    return {
+        ...part,
+        annotations: Array.isArray(part.annotations) ? [...part.annotations] : [],
+    };
+}
+function cloneOutputItem(item) {
+    if (item.type === 'message') {
+        const message = item;
+        return {
+            ...message,
+            content: message.content.map((part) => {
+                if (part.type === 'output_text')
+                    return cloneOutputTextPart(part);
+                return part;
+            }),
+        };
+    }
+    if (item.type === 'function_call') {
+        return { ...item };
+    }
+    return item;
+}
+export class OpenAiResponsesState {
+    itemIdFn;
+    output = [];
+    textItems = new Map();
+    functionCalls = new Map();
+    constructor(itemIdFn) {
+        this.itemIdFn = itemIdFn;
+    }
+    getOutput() {
+        return this.output;
+    }
+    collectOutputText() {
+        const parts = [];
+        for (const item of this.output) {
+            if (item.type !== 'message')
+                continue;
+            for (const part of item.content) {
+                if (part.type === 'output_text' && part.text)
+                    parts.push(part.text);
+            }
+        }
+        return parts.join('');
+    }
+    hasTextStream(streamId) {
+        return this.textItems.has(streamId);
+    }
+    ensureMessage(streamId, params) {
+        if (this.textItems.has(streamId))
+            return [];
+        const outputIndex = this.output.length;
+        const resolvedItemId = params.itemId ?? this.itemIdFn();
+        const message = {
+            id: resolvedItemId,
+            type: 'message',
+            role: params.role,
+            status: 'in_progress',
+            content: [],
+        };
+        this.output.push(message);
+        this.textItems.set(streamId, {
+            outputIndex,
+            itemId: resolvedItemId,
+            contentIndex: 0,
+            text: '',
+            contentStarted: false,
+            outputTextDone: false,
+            contentPartDone: false,
+            outputItemDone: false,
+        });
+        return [
+            {
+                type: 'response.output_item.added',
+                output_index: outputIndex,
+                item: cloneOutputItem(message),
+            },
+        ];
+    }
+    ensureAssistantMessage(streamId, itemId) {
+        return this.ensureMessage(streamId, { role: 'assistant', itemId });
+    }
+    ensureTextPart(streamId) {
+        const out = [];
+        if (!this.textItems.has(streamId))
+            out.push(...this.ensureAssistantMessage(streamId));
+        const st = this.textItems.get(streamId);
+        if (!st || st.outputItemDone)
+            return out;
+        if (st.contentStarted)
+            return out;
+        st.contentStarted = true;
+        const item = this.output[st.outputIndex];
+        if (!item || item.type !== 'message')
+            return out;
+        const part = { type: 'output_text', text: '', annotations: [] };
+        item.content.push(part);
+        out.push({
+            type: 'response.content_part.added',
+            output_index: st.outputIndex,
+            item_id: st.itemId,
+            content_index: st.contentIndex,
+            part: cloneOutputTextPart(part),
+        });
+        return out;
+    }
+    appendTextDelta(streamId, delta) {
+        const out = [];
+        out.push(...this.ensureTextPart(streamId));
+        const st = this.textItems.get(streamId);
+        if (!st || st.outputItemDone)
+            return out;
+        st.text += delta;
+        out.push({
+            type: 'response.output_text.delta',
+            output_index: st.outputIndex,
+            item_id: st.itemId,
+            content_index: st.contentIndex,
+            delta,
+            logprobs: [],
+        });
+        return out;
+    }
+    doneOutputText(streamId, text) {
+        const out = [];
+        out.push(...this.ensureTextPart(streamId));
+        const st = this.textItems.get(streamId);
+        if (!st || st.outputItemDone)
+            return out;
+        if (st.outputTextDone)
+            return out;
+        if (typeof text === 'string')
+            st.text = text;
+        const item = this.output[st.outputIndex];
+        if (!item || item.type !== 'message')
+            return out;
+        const part = { type: 'output_text', text: st.text, annotations: [] };
+        if (item.content.length === 0)
+            item.content.push(part);
+        else
+            item.content[0] = part;
+        st.outputTextDone = true;
+        out.push({
+            type: 'response.output_text.done',
+            output_index: st.outputIndex,
+            item_id: st.itemId,
+            content_index: st.contentIndex,
+            text: st.text,
+            logprobs: [],
+        });
+        return out;
+    }
+    doneContentPart(streamId) {
+        const out = [];
+        out.push(...this.ensureTextPart(streamId));
+        const st = this.textItems.get(streamId);
+        if (!st || st.outputItemDone)
+            return out;
+        if (st.contentPartDone)
+            return out;
+        const item = this.output[st.outputIndex];
+        if (!item || item.type !== 'message')
+            return out;
+        const part = { type: 'output_text', text: st.text, annotations: [] };
+        if (item.content.length === 0)
+            item.content.push(part);
+        else
+            item.content[0] = part;
+        st.contentPartDone = true;
+        out.push({
+            type: 'response.content_part.done',
+            output_index: st.outputIndex,
+            item_id: st.itemId,
+            content_index: st.contentIndex,
+            part: cloneOutputTextPart(part),
+        });
+        return out;
+    }
+    doneMessageItem(streamId) {
+        const out = [];
+        out.push(...this.ensureTextPart(streamId));
+        const st = this.textItems.get(streamId);
+        if (!st || st.outputItemDone)
+            return out;
+        const item = this.output[st.outputIndex];
+        if (!item || item.type !== 'message')
+            return out;
+        const part = { type: 'output_text', text: st.text, annotations: [] };
+        if (item.content.length === 0)
+            item.content.push(part);
+        else
+            item.content[0] = part;
+        st.outputItemDone = true;
+        item.status = 'completed';
+        out.push({
+            type: 'response.output_item.done',
+            output_index: st.outputIndex,
+            item: cloneOutputItem(item),
+        });
+        return out;
+    }
+    finishText(streamId, text) {
+        const out = [];
+        out.push(...this.doneOutputText(streamId, text));
+        out.push(...this.doneContentPart(streamId));
+        out.push(...this.doneMessageItem(streamId));
+        return out;
+    }
+    hasFunctionCall(callId) {
+        return this.functionCalls.has(callId);
+    }
+    startFunctionCall(callId, toolName, itemId) {
+        if (this.functionCalls.has(callId))
+            return [];
+        const outputIndex = this.output.length;
+        const resolvedItemId = itemId ?? this.itemIdFn();
+        const item = {
+            id: resolvedItemId,
+            type: 'function_call',
+            call_id: callId,
+            name: toolName,
+            arguments: '',
+            status: 'in_progress',
+        };
+        this.output.push(item);
+        this.functionCalls.set(callId, {
+            outputIndex,
+            itemId: resolvedItemId,
+            name: toolName,
+            args: '',
+            done: false,
+        });
+        return [
+            {
+                type: 'response.output_item.added',
+                output_index: outputIndex,
+                item: cloneOutputItem(item),
+            },
+        ];
+    }
+    appendFunctionCallArgs(callId, delta) {
+        const st = this.functionCalls.get(callId);
+        if (!st || st.done)
+            return [];
+        st.args += delta;
+        return [
+            {
+                type: 'response.function_call_arguments.delta',
+                output_index: st.outputIndex,
+                item_id: st.itemId,
+                delta,
+            },
+        ];
+    }
+    finishFunctionCallArgs(callId, args, toolName) {
+        const st = this.functionCalls.get(callId);
+        if (!st || st.done)
+            return [];
+        st.args = args;
+        const item = this.output[st.outputIndex];
+        if (item && item.type === 'function_call')
+            item.arguments = args;
+        return [
+            {
+                type: 'response.function_call_arguments.done',
+                output_index: st.outputIndex,
+                item_id: st.itemId,
+                name: toolName ?? st.name,
+                arguments: args,
+            },
+        ];
+    }
+    finishFunctionCall(callId, args) {
+        const st = this.functionCalls.get(callId);
+        if (!st || st.done)
+            return [];
+        st.done = true;
+        st.args = args;
+        const item = this.output[st.outputIndex];
+        if (!item || item.type !== 'function_call')
+            return [];
+        item.arguments = st.args;
+        item.status = 'completed';
+        return [
+            {
+                type: 'response.output_item.done',
+                output_index: st.outputIndex,
+                item: cloneOutputItem(item),
+            },
+        ];
+    }
+}
+//# sourceMappingURL=openai-responses-state.js.map