salmon-loop 0.2.3

package/dist/core/strata/types.js

@@ -0,0 +1,46 @@
+/**
+ * StrataSystem Types and Interfaces
+ *
+ * This file defines the core types and interfaces for the StrataSystem architecture.
+ * All types are exported for use across L1, L2, and L3 layers.
+ */
+/**
+ * ShadowMergeEngine Options
+ * (Removed to avoid duplication with engine/shadow-merge-engine.ts if it exports it)
+ * Actually, shadow-merge-engine.ts defines ShadowMergeEngineOptions.
+ * We should remove it from here if it is duplicate.
+ */
+// export interface ShadowMergeEngineOptions { ... }
+// Checking if it is here.
+/**
+ * Default ShadowDriver Configuration
+ */
+export const DEFAULT_SHADOW_DRIVER_CONFIG = {
+    whitelist: [],
+    dependencyPaths: [],
+    readonly: false,
+    platform: process.platform,
+    repoRoot: '',
+    shadowRoot: '',
+};
+/**
+ * Write Operation Blacklist
+ * Commands that trigger write operations and require ISOLATED strategy
+ */
+export const WRITE_OP_BLACKLIST = [
+    'install',
+    'update',
+    'add',
+    'remove',
+    'build',
+    'compile',
+    'bun install',
+    'bun add',
+    'cargo build',
+    'cargo run',
+    'go mod',
+    'go get',
+    'pip install',
+    'pipenv install',
+];
+//# sourceMappingURL=types.js.map

package/dist/core/streaming/canonical/canonical-responses-event-emitter.js

@@ -0,0 +1,326 @@
+import { formatCanonicalFunctionCallItemId } from './function-call-item-id.js';
+import { createResponseFunctionCallArgumentsDeltaEvent, createResponseFunctionCallArgumentsDoneEvent, createResponseOutputTextDeltaEvent, createResponseOutputTextDoneEvent, } from './responses-event-emitter.js';
+// CRITICAL SAFETY: tool arguments may include file contents, secrets, or user data.
+// Canonical events are safe-by-default, so arguments must be redacted unless explicitly opted in.
+const REDACTED_TOOL_ARGS = '{}';
+/**
+ * A provider-agnostic canonical responses event generator.
+ *
+ * This emitter intentionally only solves event translation + minimal state (ids/indexes),
+ * leaving message/block assembly to `StreamAssembler` and protocol encoding to adapters.
+ */
+export class CanonicalResponsesEventEmitter {
+    toolArgsMode;
+    textStreams = new Map();
+    functionCalls = new Map();
+    constructor(options = {}) {
+        this.toolArgsMode = options.toolArgs ?? 'redact';
+    }
+    push(part) {
+        switch (part.type) {
+            case 'output_text.delta': {
+                return this.onOutputTextDelta(part.streamId, part.delta, part.logprobs);
+            }
+            case 'output_text.done': {
+                return this.onOutputTextDone(part.streamId, part.text, part.logprobs);
+            }
+            case 'function_call.start': {
+                return this.onFunctionCallStart(part.streamId, part.callId, part.name);
+            }
+            case 'function_call_arguments.delta': {
+                return this.onFunctionCallArgsDelta(part.streamId, part.callId, part.delta);
+            }
+            case 'function_call_arguments.done': {
+                return this.onFunctionCallArgsDone(part.streamId, part.callId, part.arguments, part.name);
+            }
+            case 'function_call.done': {
+                return this.onFunctionCallDone(part.streamId, part.callId, part.name, part.arguments);
+            }
+        }
+    }
+    /**
+     * Flushes any open items in the given stream to a "done" state, producing
+     * the missing canonical *done* events in a stable order.
+     */
+    finish(streamId) {
+        const out = [];
+        const text = this.textStreams.get(streamId);
+        if (text)
+            out.push(...this.flushTextStream(text));
+        for (const call of this.functionCalls.values()) {
+            if (call.streamId !== streamId)
+                continue;
+            out.push(...this.flushFunctionCall(call));
+        }
+        return out;
+    }
+    onOutputTextDelta(streamId, delta, logprobs) {
+        const out = [];
+        const st = this.ensureTextStream(streamId);
+        out.push(...this.ensureTextContentPartAdded(st));
+        if (st.messageItemDone)
+            return out;
+        st.text += delta;
+        out.push(createResponseOutputTextDeltaEvent({
+            delta,
+            logprobs,
+        }));
+        return out;
+    }
+    onOutputTextDone(streamId, text, logprobs) {
+        const out = [];
+        const st = this.ensureTextStream(streamId);
+        out.push(...this.ensureTextContentPartAdded(st));
+        if (st.messageItemDone)
+            return out;
+        if (typeof text === 'string')
+            st.text = text;
+        if (st.outputTextDone)
+            return out;
+        st.outputTextDone = true;
+        out.push(createResponseOutputTextDoneEvent({
+            text: st.text,
+            logprobs,
+        }));
+        return out;
+    }
+    ensureTextStream(streamId) {
+        const existing = this.textStreams.get(streamId);
+        if (existing)
+            return existing;
+        const st = {
+            contentPartAdded: false,
+            outputTextDone: false,
+            contentPartDone: false,
+            messageItemDone: false,
+            text: '',
+        };
+        this.textStreams.set(streamId, st);
+        return st;
+    }
+    ensureTextContentPartAdded(st) {
+        if (st.contentPartAdded)
+            return [];
+        if (st.messageItemDone)
+            return [];
+        st.contentPartAdded = true;
+        return [
+            {
+                type: 'response.output_item.added',
+                item: {
+                    type: 'message',
+                    role: 'assistant',
+                    status: 'in_progress',
+                    content: [],
+                },
+            },
+            {
+                type: 'response.content_part.added',
+                part: { type: 'output_text', text: '', annotations: [] },
+            },
+        ];
+    }
+    flushTextStream(st) {
+        const out = [];
+        out.push(...this.ensureTextContentPartAdded(st));
+        if (!st.outputTextDone && !st.messageItemDone) {
+            st.outputTextDone = true;
+            out.push(createResponseOutputTextDoneEvent({
+                text: st.text,
+                logprobs: [],
+            }));
+        }
+        if (!st.contentPartDone && !st.messageItemDone) {
+            st.contentPartDone = true;
+            out.push({
+                type: 'response.content_part.done',
+                part: { type: 'output_text', text: st.text, annotations: [] },
+            });
+        }
+        if (!st.messageItemDone) {
+            st.messageItemDone = true;
+            out.push({
+                type: 'response.output_item.done',
+                item: {
+                    type: 'message',
+                    role: 'assistant',
+                    status: 'completed',
+                    content: [{ type: 'output_text', text: st.text, annotations: [] }],
+                },
+            });
+        }
+        return out;
+    }
+    ensureFunctionCallStarted(streamId, callId, name) {
+        const existing = this.functionCalls.get(callId);
+        if (existing)
+            return [];
+        const argsItemId = formatCanonicalFunctionCallItemId(callId);
+        const st = {
+            streamId,
+            callId,
+            argsItemId,
+            toolName: name,
+            args: '',
+            addedEmitted: false,
+            argsDeltaEmitted: false,
+            argsDoneEmitted: false,
+            itemDoneEmitted: false,
+            pendingArgsDeltas: [],
+            pendingArgsDone: null,
+        };
+        this.functionCalls.set(callId, st);
+        return [];
+    }
+    onFunctionCallStart(streamId, callId, name) {
+        const out = [];
+        out.push(...this.ensureFunctionCallStarted(streamId, callId, name));
+        const st = this.functionCalls.get(callId);
+        if (!st || st.itemDoneEmitted)
+            return out;
+        st.streamId = streamId;
+        if (st.toolName === 'unknown' && name !== 'unknown')
+            st.toolName = name;
+        out.push(...this.ensureFunctionCallAdded(st));
+        out.push(...this.flushPendingFunctionCallArgs(st));
+        return out;
+    }
+    ensureFunctionCallAdded(st) {
+        if (st.addedEmitted)
+            return [];
+        if (st.toolName === 'unknown')
+            return [];
+        st.addedEmitted = true;
+        return [
+            {
+                type: 'response.output_item.added',
+                item: {
+                    type: 'function_call',
+                    call_id: st.callId,
+                    name: st.toolName,
+                    arguments: '',
+                    status: 'in_progress',
+                },
+            },
+        ];
+    }
+    onFunctionCallArgsDelta(streamId, callId, delta) {
+        const out = [];
+        out.push(...this.ensureFunctionCallStarted(streamId, callId, 'unknown'));
+        const st = this.functionCalls.get(callId);
+        if (!st || st.itemDoneEmitted)
+            return out;
+        st.streamId = streamId;
+        if (!st.addedEmitted) {
+            st.pendingArgsDeltas.push(delta);
+            return out;
+        }
+        if (this.toolArgsMode === 'redact') {
+            if (st.argsDeltaEmitted)
+                return out;
+            st.argsDeltaEmitted = true;
+            out.push(createResponseFunctionCallArgumentsDeltaEvent({
+                itemId: st.argsItemId,
+                delta: REDACTED_TOOL_ARGS,
+            }));
+            return out;
+        }
+        st.args += delta;
+        out.push(createResponseFunctionCallArgumentsDeltaEvent({
+            itemId: st.argsItemId,
+            delta,
+        }));
+        return out;
+    }
+    onFunctionCallArgsDone(streamId, callId, argumentsText, name) {
+        const out = [];
+        out.push(...this.ensureFunctionCallStarted(streamId, callId, name ?? 'unknown'));
+        const st = this.functionCalls.get(callId);
+        if (!st || st.itemDoneEmitted)
+            return out;
+        if (st.argsDoneEmitted)
+            return out;
+        st.streamId = streamId;
+        if (typeof name === 'string' && name && st.toolName === 'unknown')
+            st.toolName = name;
+        if (!st.addedEmitted) {
+            st.pendingArgsDone = { argumentsText, name };
+            out.push(...this.ensureFunctionCallAdded(st));
+            out.push(...this.flushPendingFunctionCallArgs(st));
+            return out;
+        }
+        if (this.toolArgsMode === 'redact') {
+            if (!st.argsDeltaEmitted) {
+                st.argsDeltaEmitted = true;
+                out.push(createResponseFunctionCallArgumentsDeltaEvent({
+                    itemId: st.argsItemId,
+                    delta: REDACTED_TOOL_ARGS,
+                }));
+            }
+            st.argsDoneEmitted = true;
+            st.args = REDACTED_TOOL_ARGS;
+            out.push(createResponseFunctionCallArgumentsDoneEvent({
+                itemId: st.argsItemId,
+                name: name ?? st.toolName,
+                argumentsText: REDACTED_TOOL_ARGS,
+            }));
+            return out;
+        }
+        st.argsDoneEmitted = true;
+        st.args = argumentsText;
+        out.push(createResponseFunctionCallArgumentsDoneEvent({
+            itemId: st.argsItemId,
+            name: name ?? st.toolName,
+            argumentsText,
+        }));
+        return out;
+    }
+    onFunctionCallDone(streamId, callId, name, argumentsText) {
+        const out = [];
+        out.push(...this.ensureFunctionCallStarted(streamId, callId, name));
+        const st = this.functionCalls.get(callId);
+        if (!st || st.itemDoneEmitted)
+            return out;
+        out.push(...this.onFunctionCallArgsDone(streamId, callId, argumentsText, name));
+        out.push(...this.flushFunctionCall(st));
+        return out;
+    }
+    flushFunctionCall(st) {
+        const out = [];
+        if (st.itemDoneEmitted)
+            return out;
+        out.push(...this.ensureFunctionCallAdded(st));
+        out.push(...this.flushPendingFunctionCallArgs(st));
+        if (!st.argsDoneEmitted) {
+            out.push(...this.onFunctionCallArgsDone(st.streamId, st.callId, st.args, st.toolName));
+        }
+        st.itemDoneEmitted = true;
+        out.push({
+            type: 'response.output_item.done',
+            item: {
+                type: 'function_call',
+                call_id: st.callId,
+                name: st.toolName,
+                arguments: st.args,
+                status: 'completed',
+            },
+        });
+        return out;
+    }
+    flushPendingFunctionCallArgs(st) {
+        const out = [];
+        if (!st.addedEmitted)
+            return out;
+        for (const delta of st.pendingArgsDeltas) {
+            out.push(...this.onFunctionCallArgsDelta(st.streamId, st.callId, delta));
+        }
+        st.pendingArgsDeltas = [];
+        if (st.pendingArgsDone) {
+            const done = st.pendingArgsDone;
+            st.pendingArgsDone = null;
+            out.push(...this.onFunctionCallArgsDone(st.streamId, st.callId, done.argumentsText, done.name));
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=canonical-responses-event-emitter.js.map

package/dist/core/streaming/canonical/function-call-item-id.js

@@ -0,0 +1,13 @@
+const PREFIX = 'function_call:';
+export function formatCanonicalFunctionCallItemId(callId) {
+    return `${PREFIX}${callId}`;
+}
+export function parseCanonicalFunctionCallItemId(itemId) {
+    if (!itemId)
+        return null;
+    if (!itemId.startsWith(PREFIX))
+        return null;
+    const callId = itemId.slice(PREFIX.length);
+    return callId ? callId : null;
+}
+//# sourceMappingURL=function-call-item-id.js.map

package/dist/core/streaming/canonical/parts-from-llm-stream-chunk.js

@@ -0,0 +1,54 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function getString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : null;
+}
+function getRecord(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : null;
+}
+/**
+ * Best-effort conversion from our provider-agnostic `LLMStreamChunk` into
+ * provider-agnostic canonical stream parts.
+ *
+ * Notes:
+ * - This function intentionally does not sanitize text/tool args. Sanitization
+ *   belongs to the caller (e.g., `output-policy` / redaction policies).
+ * - Tool call arguments are surfaced as *done* parts (not deltas) because our
+ *   current `LLMStreamChunk` contract does not carry argument deltas.
+ */
+export function mapLlmStreamChunkToCanonicalStreamParts(params) {
+    const out = [];
+    const { streamId, chunk } = params;
+    if (typeof chunk.contentDelta === 'string' && chunk.contentDelta) {
+        out.push({ type: 'output_text.delta', streamId, delta: chunk.contentDelta });
+    }
+    if (Array.isArray(chunk.tool_calls)) {
+        for (const callUnknown of chunk.tool_calls) {
+            if (!isRecord(callUnknown))
+                continue;
+            const callId = getString(callUnknown, 'id');
+            const fn = getRecord(callUnknown, 'function');
+            const toolName = fn ? getString(fn, 'name') : null;
+            const args = fn ? getString(fn, 'arguments') : null;
+            if (!callId)
+                continue;
+            if (!toolName)
+                continue;
+            out.push({ type: 'function_call.start', streamId, callId, name: toolName });
+            if (args !== null) {
+                out.push({
+                    type: 'function_call_arguments.done',
+                    streamId,
+                    callId,
+                    name: toolName ?? undefined,
+                    arguments: args,
+                });
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=parts-from-llm-stream-chunk.js.map

package/dist/core/streaming/canonical/responses-event-emitter.js

@@ -0,0 +1,127 @@
+export function createResponseOutputTextDeltaEvent(params) {
+    if (typeof params === 'string') {
+        return { type: 'response.output_text.delta', delta: params };
+    }
+    return {
+        type: 'response.output_text.delta',
+        delta: params.delta,
+        output_index: params.outputIndex,
+        item_id: params.itemId,
+        content_index: params.contentIndex,
+        logprobs: params.logprobs,
+    };
+}
+export function createResponseOutputTextDoneEvent(params) {
+    return {
+        type: 'response.output_text.done',
+        output_index: params?.outputIndex,
+        item_id: params?.itemId,
+        content_index: params?.contentIndex,
+        text: params?.text,
+        logprobs: params?.logprobs,
+    };
+}
+export function createResponseOutputItemAddedMessageEvent(params) {
+    const item = {
+        id: params.itemId,
+        type: 'message',
+        role: params.role,
+        status: 'in_progress',
+        content: [],
+    };
+    return {
+        type: 'response.output_item.added',
+        output_index: params.outputIndex,
+        item,
+    };
+}
+export function createResponseOutputItemDoneMessageEvent(params) {
+    const item = {
+        id: params.itemId,
+        type: 'message',
+        role: params.role,
+        status: 'completed',
+        content: params.content,
+    };
+    return {
+        type: 'response.output_item.done',
+        output_index: params.outputIndex,
+        item,
+    };
+}
+export function createResponseContentPartAddedOutputTextEvent(params) {
+    const part = {
+        type: 'output_text',
+        text: '',
+        annotations: [],
+    };
+    return {
+        type: 'response.content_part.added',
+        output_index: params.outputIndex,
+        item_id: params.itemId,
+        content_index: params.contentIndex,
+        part,
+    };
+}
+export function createResponseContentPartDoneOutputTextEvent(params) {
+    const part = {
+        type: 'output_text',
+        text: params.text,
+        annotations: [],
+    };
+    return {
+        type: 'response.content_part.done',
+        output_index: params.outputIndex,
+        item_id: params.itemId,
+        content_index: params.contentIndex,
+        part,
+    };
+}
+export function createResponseFunctionCallArgumentsDeltaEvent(params) {
+    return {
+        type: 'response.function_call_arguments.delta',
+        output_index: params.outputIndex,
+        item_id: params.itemId,
+        delta: params.delta,
+    };
+}
+export function createResponseFunctionCallArgumentsDoneEvent(params) {
+    return {
+        type: 'response.function_call_arguments.done',
+        output_index: params.outputIndex,
+        item_id: params.itemId,
+        name: params.name,
+        arguments: params.argumentsText,
+    };
+}
+export function createResponseOutputItemAddedFunctionCallEvent(params) {
+    const item = {
+        id: params.itemId,
+        type: 'function_call',
+        call_id: params.callId,
+        name: params.name,
+        arguments: params.argumentsText,
+        status: 'in_progress',
+    };
+    return {
+        type: 'response.output_item.added',
+        output_index: params.outputIndex,
+        item,
+    };
+}
+export function createResponseOutputItemDoneFunctionCallEvent(params) {
+    const item = {
+        id: params.itemId,
+        type: 'function_call',
+        call_id: params.callId,
+        name: params.name,
+        arguments: params.argumentsText,
+        status: 'completed',
+    };
+    return {
+        type: 'response.output_item.done',
+        output_index: params.outputIndex,
+        item,
+    };
+}
+//# sourceMappingURL=responses-event-emitter.js.map

package/dist/core/streaming/canonical/responses-events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=responses-events.js.map

package/dist/core/streaming/normalized-events.js

@@ -0,0 +1,9 @@
+export function normalizeStopReason(raw) {
+    if (raw === 'end_turn' || raw === 'tool_use' || raw === 'error' || raw === 'cancelled') {
+        return raw;
+    }
+    if (raw)
+        return 'unknown';
+    return 'end_turn';
+}
+//# sourceMappingURL=normalized-events.js.map

package/dist/core/streaming/normalized-from-text.js

@@ -0,0 +1,47 @@
+import { normalizeStopReason } from './normalized-events.js';
+export function createAssistantTextMessageEvents(params) {
+    const blockId = `${params.messageId}:text:0`;
+    const out = [
+        {
+            type: 'normalized.message_start',
+            messageId: params.messageId,
+            role: 'assistant',
+            source: 'llm',
+            timestamp: params.timestamp,
+        },
+        {
+            type: 'normalized.content_block_start',
+            messageId: params.messageId,
+            blockId,
+            blockType: 'text',
+            index: 0,
+            timestamp: params.timestamp,
+        },
+    ];
+    if (params.text) {
+        out.push({
+            type: 'normalized.content_block_delta',
+            messageId: params.messageId,
+            blockId,
+            index: 0,
+            deltaType: 'text',
+            text: params.text,
+            timestamp: params.timestamp,
+        });
+    }
+    out.push({
+        type: 'normalized.content_block_end',
+        messageId: params.messageId,
+        blockId,
+        index: 0,
+        timestamp: params.timestamp,
+    }, {
+        type: 'normalized.message_end',
+        messageId: params.messageId,
+        stopReason: normalizeStopReason(params.finishReason),
+        finishReason: params.finishReason,
+        timestamp: params.timestamp,
+    });
+    return out;
+}
+//# sourceMappingURL=normalized-from-text.js.map