salmon-loop 0.2.3

package/dist/core/streaming/stream-assembler.js

@@ -0,0 +1,347 @@
+import { getExitCode } from '../runtime/exit-codes.js';
+import { normalizeStopReason } from './normalized-events.js';
+export class StreamAssembler {
+    clock;
+    streams = new Map();
+    canonicalTextStreams = new Set();
+    canonicalClosedTextStreams = new Set();
+    toolCallStates = new Map();
+    constructor(options = {}) {
+        this.clock = options.clock ?? (() => new Date());
+    }
+    push(event) {
+        if (event.type === 'llm.responses.event') {
+            return this.handleResponsesLoopEvent(event);
+        }
+        if (event.type === 'llm.stream.delta' && this.canonicalTextStreams.has(event.streamId)) {
+            return [];
+        }
+        if (event.type === 'llm.stream.delta') {
+            return this.handleTextDelta(event.streamId, event.timestamp, event.content);
+        }
+        if (event.type === 'llm.stream.end') {
+            if (this.canonicalClosedTextStreams.has(event.streamId)) {
+                this.canonicalClosedTextStreams.delete(event.streamId);
+                this.canonicalTextStreams.delete(event.streamId);
+                this.streams.delete(event.streamId);
+                return [];
+            }
+            this.canonicalTextStreams.delete(event.streamId);
+            return this.handleTextEnd(event.streamId, event.timestamp, event.finishReason);
+        }
+        if (event.type === 'tool.call.start') {
+            const out = [];
+            const st = this.getToolCallState(event.callId);
+            if (!st.requestStarted) {
+                st.requestStarted = true;
+                out.push({
+                    type: 'normalized.tool_request_start',
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                });
+            }
+            if (!st.requestEnded) {
+                st.requestEnded = true;
+                out.push({
+                    type: 'normalized.tool_request_end',
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                });
+            }
+            if (st.executionStarted)
+                return out;
+            st.executionStarted = true;
+            out.push({
+                type: 'normalized.tool_call_start',
+                callId: event.callId,
+                toolName: event.toolName,
+                phase: event.phase,
+                round: event.round,
+                ...(event.input === undefined ? {} : { input: event.input }),
+                timestamp: event.timestamp,
+            });
+            return out;
+        }
+        if (event.type === 'tool.call.end') {
+            const out = [];
+            const st = this.getToolCallState(event.callId);
+            if (!st.requestStarted) {
+                st.requestStarted = true;
+                out.push({
+                    type: 'normalized.tool_request_start',
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                });
+            }
+            if (!st.requestEnded) {
+                st.requestEnded = true;
+                out.push({
+                    type: 'normalized.tool_request_end',
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                });
+            }
+            out.push({
+                type: 'normalized.tool_call_end',
+                callId: event.callId,
+                toolName: event.toolName,
+                phase: event.phase,
+                round: event.round,
+                status: event.status,
+                durationMs: event.durationMs,
+                errorCode: event.errorCode,
+                outputSummary: event.outputSummary,
+                timestamp: event.timestamp,
+            });
+            this.toolCallStates.delete(event.callId);
+            return out;
+        }
+        return [];
+    }
+    finish(result) {
+        this.streams.clear();
+        this.canonicalTextStreams.clear();
+        this.canonicalClosedTextStreams.clear();
+        this.toolCallStates.clear();
+        return [
+            {
+                type: 'normalized.run_end',
+                success: Boolean(result.success),
+                exitCode: getExitCode(result),
+                reason: result.reason,
+                reasonCode: result.reasonCode,
+                diagnosticCode: result.diagnosticCode,
+                safeHint: result.safeHint,
+                remediationSteps: result.remediationSteps,
+                timestamp: this.clock(),
+            },
+        ];
+    }
+    ensureTextStreamStarted(streamId, at) {
+        const existing = this.streams.get(streamId);
+        if (existing?.started && existing.textBlockOpen)
+            return [];
+        const state = existing ?? {
+            messageId: streamId,
+            textBlockId: `${streamId}:text:0`,
+            started: false,
+            textBlockOpen: false,
+        };
+        state.started = true;
+        state.textBlockOpen = true;
+        this.streams.set(streamId, state);
+        return [
+            {
+                type: 'normalized.message_start',
+                messageId: state.messageId,
+                role: 'assistant',
+                source: 'llm',
+                timestamp: at,
+            },
+            {
+                type: 'normalized.content_block_start',
+                messageId: state.messageId,
+                blockId: state.textBlockId,
+                blockType: 'text',
+                index: 0,
+                timestamp: at,
+            },
+        ];
+    }
+    handleTextDelta(streamId, at, text) {
+        const prelude = this.ensureTextStreamStarted(streamId, at);
+        const state = this.streams.get(streamId);
+        if (!state)
+            return prelude;
+        return [
+            ...prelude,
+            {
+                type: 'normalized.content_block_delta',
+                messageId: state.messageId,
+                blockId: state.textBlockId,
+                index: 0,
+                deltaType: 'text',
+                text,
+                timestamp: at,
+            },
+        ];
+    }
+    handleTextEnd(streamId, at, finishReason) {
+        const prelude = this.ensureTextStreamStarted(streamId, at);
+        const state = this.streams.get(streamId);
+        const out = [...prelude];
+        if (state?.textBlockOpen) {
+            out.push({
+                type: 'normalized.content_block_end',
+                messageId: state.messageId,
+                blockId: state.textBlockId,
+                index: 0,
+                timestamp: at,
+            });
+        }
+        out.push({
+            type: 'normalized.message_end',
+            messageId: state?.messageId ?? streamId,
+            stopReason: normalizeStopReason(finishReason),
+            finishReason,
+            timestamp: at,
+        });
+        this.streams.delete(streamId);
+        return out;
+    }
+    handleResponsesLoopEvent(event) {
+        if (isOutputTextDeltaEvent(event.event)) {
+            this.canonicalTextStreams.add(event.streamId);
+            return this.handleTextDelta(event.streamId, event.timestamp, event.event.delta);
+        }
+        if (isOutputTextDoneEvent(event.event)) {
+            if (this.canonicalClosedTextStreams.has(event.streamId))
+                return [];
+            this.canonicalClosedTextStreams.add(event.streamId);
+            this.canonicalTextStreams.delete(event.streamId);
+            return this.handleTextEnd(event.streamId, event.timestamp, undefined);
+        }
+        if (isOutputItemAddedMessageEvent(event.event) ||
+            isContentPartAddedOutputTextEvent(event.event)) {
+            return this.ensureTextStreamStarted(event.streamId, event.timestamp);
+        }
+        if (isOutputItemDoneMessageEvent(event.event) ||
+            isContentPartDoneOutputTextEvent(event.event)) {
+            if (this.canonicalClosedTextStreams.has(event.streamId))
+                return [];
+            this.canonicalClosedTextStreams.add(event.streamId);
+            this.canonicalTextStreams.delete(event.streamId);
+            return this.handleTextEnd(event.streamId, event.timestamp, undefined);
+        }
+        if (isOutputItemAddedFunctionCallEvent(event.event)) {
+            if (!event.phase || typeof event.round !== 'number')
+                return [];
+            const callId = event.event.item.call_id;
+            const toolName = event.event.item.name;
+            const st = this.getToolCallState(callId);
+            if (st.requestStarted)
+                return [];
+            st.requestStarted = true;
+            return [
+                {
+                    type: 'normalized.tool_request_start',
+                    callId,
+                    toolName,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                },
+            ];
+        }
+        if (isOutputItemDoneFunctionCallEvent(event.event)) {
+            if (!event.phase || typeof event.round !== 'number')
+                return [];
+            const callId = event.event.item.call_id;
+            const st = this.getToolCallState(callId);
+            if (st.requestEnded)
+                return [];
+            st.requestEnded = true;
+            return [
+                {
+                    type: 'normalized.tool_request_end',
+                    callId,
+                    toolName: event.event.item.name,
+                    phase: event.phase,
+                    round: event.round,
+                    timestamp: event.timestamp,
+                },
+            ];
+        }
+        return [];
+    }
+    getToolCallState(callId) {
+        const existing = this.toolCallStates.get(callId);
+        if (existing)
+            return existing;
+        const created = {
+            requestStarted: false,
+            requestEnded: false,
+            executionStarted: false,
+        };
+        this.toolCallStates.set(callId, created);
+        return created;
+    }
+}
+function isOutputTextDeltaEvent(event) {
+    return (event.type === 'response.output_text.delta' &&
+        typeof event.delta === 'string');
+}
+function isOutputTextDoneEvent(event) {
+    return event.type === 'response.output_text.done';
+}
+function isOutputItemAddedFunctionCallEvent(event) {
+    if (event.type !== 'response.output_item.added')
+        return false;
+    const candidate = event;
+    if (!candidate.item || typeof candidate.item !== 'object')
+        return false;
+    const item = candidate.item;
+    return (item.type === 'function_call' &&
+        typeof item.call_id === 'string' &&
+        typeof item.name === 'string');
+}
+function isOutputItemDoneFunctionCallEvent(event) {
+    if (event.type !== 'response.output_item.done')
+        return false;
+    const candidate = event;
+    if (!candidate.item || typeof candidate.item !== 'object')
+        return false;
+    const item = candidate.item;
+    return (item.type === 'function_call' &&
+        typeof item.call_id === 'string' &&
+        typeof item.name === 'string');
+}
+function isOutputItemAddedMessageEvent(event) {
+    if (event.type !== 'response.output_item.added')
+        return false;
+    const candidate = event;
+    if (!candidate.item || typeof candidate.item !== 'object')
+        return false;
+    const item = candidate.item;
+    return item.type === 'message' && typeof item.role === 'string';
+}
+function isOutputItemDoneMessageEvent(event) {
+    if (event.type !== 'response.output_item.done')
+        return false;
+    const candidate = event;
+    if (!candidate.item || typeof candidate.item !== 'object')
+        return false;
+    const item = candidate.item;
+    return item.type === 'message' && typeof item.role === 'string';
+}
+function isContentPartAddedOutputTextEvent(event) {
+    if (event.type !== 'response.content_part.added')
+        return false;
+    const candidate = event;
+    if (!candidate.part || typeof candidate.part !== 'object')
+        return false;
+    const part = candidate.part;
+    return part.type === 'output_text';
+}
+function isContentPartDoneOutputTextEvent(event) {
+    if (event.type !== 'response.content_part.done')
+        return false;
+    const candidate = event;
+    if (!candidate.part || typeof candidate.part !== 'object')
+        return false;
+    const part = candidate.part;
+    return part.type === 'output_text';
+}
+//# sourceMappingURL=stream-assembler.js.map

package/dist/core/structured-output/index.js

@@ -0,0 +1,3 @@
+export { extractFirstJsonValueFromText } from './json-extract.js';
+export { JsonSchemaValidator } from './json-schema-validator.js';
+//# sourceMappingURL=index.js.map

package/dist/core/structured-output/json-extract.js

@@ -0,0 +1,70 @@
+function findFirstJsonStart(text) {
+    const obj = text.indexOf('{');
+    const arr = text.indexOf('[');
+    if (obj === -1)
+        return arr;
+    if (arr === -1)
+        return obj;
+    return Math.min(obj, arr);
+}
+function findMatchingJsonEnd(text, start) {
+    const open = text[start];
+    const close = open === '{' ? '}' : open === '[' ? ']' : '';
+    if (!close)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === open)
+            depth += 1;
+        if (ch === close)
+            depth -= 1;
+        if (depth === 0)
+            return i;
+    }
+    return null;
+}
+/**
+ * Best-effort strict JSON extraction from a text blob.
+ *
+ * - Finds the first '{' or '['
+ * - Extracts a balanced JSON substring
+ * - Parses via JSON.parse (no "repair" / lenient parsing)
+ */
+export function extractFirstJsonValueFromText(text) {
+    const raw = String(text ?? '');
+    const start = findFirstJsonStart(raw);
+    if (start === -1)
+        return null;
+    const end = findMatchingJsonEnd(raw, start);
+    if (end == null)
+        return null;
+    const slice = raw.slice(start, end + 1);
+    try {
+        return JSON.parse(slice);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=json-extract.js.map

package/dist/core/structured-output/json-schema-validator.js

@@ -0,0 +1,90 @@
+import { Ajv } from 'ajv';
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return '[Unserializable]';
+        }
+    }
+}
+function toSchemaKey(schema) {
+    if (!schema || typeof schema !== 'object')
+        return `non_object:${typeof schema}`;
+    return safeStringify(schema);
+}
+export class JsonSchemaValidator {
+    ajv;
+    cache = new Map();
+    cacheSize;
+    constructor(options = {}) {
+        this.cacheSize = options.cacheSize ?? 64;
+        this.ajv = new Ajv({
+            allErrors: true,
+            strict: false,
+            allowUnionTypes: true,
+        });
+    }
+    validate(params) {
+        const schema = params.schema;
+        if (!schema || typeof schema !== 'object') {
+            return {
+                ok: false,
+                error: {
+                    code: 'SCHEMA_INVALID',
+                    message: 'JSON Schema must be an object.',
+                    details: { schemaType: typeof schema },
+                },
+            };
+        }
+        const key = toSchemaKey(schema);
+        let validate = this.cache.get(key);
+        if (!validate) {
+            try {
+                validate = this.ajv.compile(schema);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    ok: false,
+                    error: {
+                        code: 'SCHEMA_INVALID',
+                        message: `Invalid JSON Schema: ${msg}`,
+                    },
+                };
+            }
+            if (this.cache.size >= this.cacheSize) {
+                const first = this.cache.keys().next().value;
+                if (first)
+                    this.cache.delete(first);
+            }
+            if (validate)
+                this.cache.set(key, validate);
+        }
+        if (!validate) {
+            return {
+                ok: false,
+                error: {
+                    code: 'SCHEMA_INVALID',
+                    message: 'Failed to compile JSON Schema.',
+                },
+            };
+        }
+        const ok = Boolean(validate(params.data));
+        if (ok)
+            return { ok: true };
+        return {
+            ok: false,
+            error: {
+                code: 'SCHEMA_VALIDATION_FAILED',
+                message: 'Structured output failed schema validation.',
+                details: validate.errors ?? undefined,
+            },
+        };
+    }
+}
+//# sourceMappingURL=json-schema-validator.js.map

package/dist/core/structured-output/types.js

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

package/dist/core/sub-agent/artifacts/store.js

@@ -0,0 +1,141 @@
+import { createHash, randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import path from 'path';
+import * as fs from '../../adapters/fs/node-fs.js';
+import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
+import { ARTIFACT_HANDLE_PREFIX } from './types.js';
+function getArtifactsRoot() {
+    // Directory naming uses "salmonloop"; protocol handles use the short "s8p://" scheme.
+    return path.join(tmpdir(), 'salmonloop', 'artifacts');
+}
+function isWithinDir(dir, target) {
+    const rel = path.relative(dir, target);
+    return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+function parseHandle(handle) {
+    if (typeof handle !== 'string')
+        return { ok: false };
+    if (!handle.startsWith(ARTIFACT_HANDLE_PREFIX))
+        return { ok: false };
+    const id = handle.slice(ARTIFACT_HANDLE_PREFIX.length).trim();
+    if (!id)
+        return { ok: false };
+    // Tighten to a safe charset to avoid path tricks.
+    if (!/^[a-z0-9-]+$/u.test(id))
+        return { ok: false };
+    return { ok: true, id };
+}
+async function sha256Text(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+export class ArtifactStore {
+    static lastGcAtMs = 0;
+    static gcTimer = null;
+    static async saveText(params) {
+        const { content, mimeType, fileExt } = params;
+        const root = getArtifactsRoot();
+        await fs.mkdir(root, { recursive: true });
+        const id = `${Date.now()}-${randomBytes(6).toString('hex')}`;
+        const filePath = path.join(root, `${id}.${fileExt}`);
+        await fs.writeFile(filePath, content, 'utf8');
+        const stat = await fs.stat(filePath);
+        const sha256 = await sha256Text(content);
+        const saved = {
+            handle: `${ARTIFACT_HANDLE_PREFIX}${id}`,
+            mimeType,
+            sha256,
+            size: stat.size,
+        };
+        await this.maybeGc();
+        return saved;
+    }
+    static async readText(handle) {
+        const parsed = parseHandle(handle);
+        if (!parsed.ok)
+            return { ok: false };
+        const root = getArtifactsRoot();
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        const match = entries.find((e) => e.isFile() && e.name.startsWith(`${parsed.id}.`));
+        if (!match)
+            return { ok: false };
+        const filePath = path.join(root, match.name);
+        if (!isWithinDir(root, filePath))
+            return { ok: false };
+        const content = await fs.readFile(filePath, 'utf8');
+        const stat = await fs.stat(filePath);
+        return { ok: true, content, size: stat.size };
+    }
+    static async gc(options) {
+        const root = getArtifactsRoot();
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        const files = [];
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const filePath = path.join(root, entry.name);
+            if (!isWithinDir(root, filePath))
+                continue;
+            const stat = await fs.stat(filePath).catch(() => null);
+            if (!stat)
+                continue;
+            files.push({ name: entry.name, path: filePath, mtimeMs: stat.mtimeMs, size: stat.size });
+        }
+        const maxAgeMs = options?.maxAgeMs ?? LIMITS.artifactTtlMs;
+        const maxFiles = options?.maxFiles ?? LIMITS.artifactMaxFiles;
+        const maxTotalBytes = options?.maxTotalBytes ?? LIMITS.artifactMaxTotalBytes;
+        const nowMs = Date.now();
+        const expired = files.filter((f) => nowMs - f.mtimeMs > maxAgeMs);
+        let removedFiles = 0;
+        let removedBytes = 0;
+        const removeFile = async (file) => {
+            await fs.rm(file.path, { force: true }).catch(() => null);
+            removedFiles += 1;
+            removedBytes += file.size;
+        };
+        for (const file of expired) {
+            await removeFile(file);
+        }
+        // Recompute remaining after TTL removal (newest first).
+        const remaining = files
+            .filter((f) => !(nowMs - f.mtimeMs > maxAgeMs))
+            .sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
+        let currentFiles = remaining.length;
+        let currentBytes = remaining.reduce((acc, f) => acc + f.size, 0);
+        for (let i = remaining.length - 1; i >= 0; i--) {
+            const tooManyFiles = currentFiles > maxFiles;
+            const tooManyBytes = currentBytes > maxTotalBytes;
+            if (!tooManyFiles && !tooManyBytes)
+                break;
+            const oldest = remaining[i];
+            await removeFile(oldest);
+            currentFiles -= 1;
+            currentBytes -= oldest.size;
+        }
+        return { removedFiles, removedBytes };
+    }
+    static async maybeGc() {
+        const nowMs = Date.now();
+        if (nowMs - this.lastGcAtMs < LIMITS.artifactGcIntervalMs)
+            return;
+        this.lastGcAtMs = nowMs;
+        try {
+            const result = await this.gc();
+            if (result.removedFiles > 0) {
+                getLogger().debug(`[ArtifactStore] GC removed ${result.removedFiles} files (${result.removedBytes} bytes)`);
+            }
+        }
+        catch {
+            // Best-effort only; never fail the caller.
+        }
+    }
+    static ensureGcLoop() {
+        if (this.gcTimer)
+            return;
+        this.gcTimer = setInterval(() => {
+            this.gc().catch(() => undefined);
+        }, LIMITS.artifactGcIntervalMs);
+        this.gcTimer.unref();
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/core/sub-agent/artifacts/types.js

@@ -0,0 +1,2 @@
+export const ARTIFACT_HANDLE_PREFIX = 's8p://artifact/';
+//# sourceMappingURL=types.js.map