salmon-loop 0.2.3

package/dist/core/tools/parallel/scheduler.js

@@ -0,0 +1,372 @@
+import { IsolationManager } from './isolation.js';
+import { resolveArgsWithResults } from './resolve-args.js';
+import { processResource, repoResource } from './resource-helpers.js';
+export class ParallelScheduler {
+    router;
+    locks;
+    isolation;
+    constructor(router, locks, isolation = new IsolationManager()) {
+        this.router = router;
+        this.locks = locks;
+        this.isolation = isolation;
+    }
+    tryResolveSpec(node) {
+        if (node.spec)
+            return node.spec;
+        const router = this.router;
+        const spec = typeof router.getSpec === 'function' ? router.getSpec(node.toolName) : undefined;
+        if (!spec)
+            return undefined;
+        node.spec = spec;
+        return spec;
+    }
+    deriveDefaultResources(spec, ctx) {
+        const writeEffects = new Set(['fs_write', 'git_write', 'snapshot_mutate']);
+        const hasWrite = spec.sideEffects.some((effect) => writeEffects.has(effect));
+        const hasProcess = spec.sideEffects.includes('process');
+        if (hasWrite || hasProcess) {
+            const resources = [repoResource(ctx)];
+            if (hasProcess)
+                resources.push(processResource(ctx));
+            return resources;
+        }
+        if (spec.sideEffects.includes('fs_read') || spec.sideEffects.includes('git_read')) {
+            return [repoResource(ctx)];
+        }
+        return [];
+    }
+    async run(plan, ctx, signal, options) {
+        const baseCtx = ctx.signal === signal ? ctx : { ...ctx, signal };
+        const recordEnabled = Boolean(options?.record ?? (plan.policy.deterministic && !options?.replay));
+        const nodeResults = { ...(options?.initialResults ?? {}) };
+        const running = new Set();
+        const blockedApprovals = [];
+        const recording = { steps: [] };
+        let stepCount = 0;
+        // Internal state tracking
+        const nodeStates = new Map();
+        for (const node of plan.nodes) {
+            const seeded = nodeResults[node.id];
+            if (seeded?.status === 'SUCCEEDED') {
+                nodeStates.set(node.id, 'SUCCEEDED');
+                continue;
+            }
+            if (seeded?.status === 'FAILED') {
+                nodeStates.set(node.id, 'FAILED');
+                continue;
+            }
+            if (seeded?.status === 'CANCELED') {
+                nodeStates.set(node.id, 'CANCELED');
+                continue;
+            }
+            if (seeded?.status === 'BLOCKED_APPROVAL') {
+                nodeStates.set(node.id, options?.resumeBlockedApprovals ? 'READY' : 'BLOCKED_APPROVAL');
+                continue;
+            }
+            nodeStates.set(node.id, (node.deps?.length ?? 0) > 0 ? 'PENDING' : 'READY');
+        }
+        const readLimit = plan.policy.readParallelism ?? plan.policy.maxParallelism;
+        const writeLimit = plan.policy.writeParallelism ?? 1;
+        let readRunning = 0;
+        let writeRunning = 0;
+        const updateDeps = () => {
+            for (const node of plan.nodes) {
+                if (nodeStates.get(node.id) !== 'PENDING')
+                    continue;
+                const deps = node.deps ?? [];
+                if (deps.length === 0) {
+                    nodeStates.set(node.id, 'READY');
+                    continue;
+                }
+                const depResults = deps.map((depId) => nodeResults[depId]);
+                const hasFailedDep = depResults.some((res) => res?.status === 'FAILED' || res?.status === 'CANCELED');
+                if (hasFailedDep) {
+                    nodeStates.set(node.id, 'CANCELED');
+                    nodeResults[node.id] = {
+                        status: 'CANCELED',
+                        error: 'Dependency failed or was canceled',
+                    };
+                    continue;
+                }
+                const allDepsDone = depResults.every((res) => res?.status === 'SUCCEEDED');
+                if (allDepsDone) {
+                    nodeStates.set(node.id, 'READY');
+                }
+            }
+        };
+        const cancelRemaining = () => {
+            for (const node of plan.nodes) {
+                const state = nodeStates.get(node.id);
+                if (state === 'PENDING' || state === 'READY') {
+                    nodeStates.set(node.id, 'CANCELED');
+                    nodeResults[node.id] = { status: 'CANCELED' };
+                }
+            }
+        };
+        const getLane = (spec) => {
+            if (!spec)
+                return 'write';
+            if (spec.concurrency === 'serial_only' || spec.concurrency === 'isolated')
+                return 'write';
+            const writeEffects = new Set(['fs_write', 'git_write', 'snapshot_mutate', 'process']);
+            if (spec.sideEffects.some((effect) => writeEffects.has(effect)))
+                return 'write';
+            return spec.concurrency === 'parallel_ok' ? 'read' : 'write';
+        };
+        const startNode = async (nodeId) => {
+            const node = plan.nodes.find((n) => n.id === nodeId);
+            let lane = null;
+            try {
+                const spec = this.tryResolveSpec(node);
+                if (!spec) {
+                    const phase = typeof baseCtx.phase === 'string' ? baseCtx.phase : undefined;
+                    const toolResult = {
+                        id: nodeId,
+                        toolName: node.toolName,
+                        source: 'builtin',
+                        status: 'denied',
+                        durationMs: 0,
+                        error: {
+                            code: 'TOOL_NOT_FOUND',
+                            message: `Tool ${node.toolName} not found`,
+                            retryable: false,
+                            ...(phase ? { failurePhase: phase } : {}),
+                        },
+                    };
+                    nodeStates.set(nodeId, 'FAILED');
+                    nodeResults[nodeId] = {
+                        status: 'FAILED',
+                        error: toolResult.error,
+                        toolResult,
+                        timing: { lockWaitMs: 0, runMs: 0 },
+                    };
+                    if (plan.policy.failFast)
+                        cancelRemaining();
+                    return;
+                }
+                lane = getLane(spec);
+                nodeStates.set(nodeId, 'RUNNING');
+                if (lane === 'read')
+                    readRunning++;
+                else if (lane === 'write')
+                    writeRunning++;
+                if (recordEnabled) {
+                    recording.steps.push({
+                        t: stepCount++,
+                        picked: nodeId,
+                        readySet: Array.from(nodeStates.entries())
+                            .filter(([_, s]) => s === 'READY' || s === 'RUNNING') // Include current node which was READY
+                            .map(([id]) => id),
+                        readRunning,
+                        writeRunning: writeRunning || 0,
+                    });
+                }
+                // 1. Resolve Arguments
+                const resolvedArgs = resolveArgsWithResults(node.args, nodeResults);
+                // 1.5 Deferred authorization preflight (avoid holding locks while waiting for user)
+                const preflight = typeof this.router.preflightDeferredAuthorization === 'function'
+                    ? await this.router.preflightDeferredAuthorization({
+                        id: nodeId,
+                        phase: baseCtx.phase || 'execute',
+                        toolName: node.toolName,
+                        args: resolvedArgs,
+                        ctx: baseCtx,
+                    })
+                    : null;
+                if (preflight?.kind === 'pending') {
+                    nodeStates.set(nodeId, 'BLOCKED_APPROVAL');
+                    const approval = {
+                        nodeId,
+                        toolName: node.toolName,
+                        riskLevel: spec.riskLevel,
+                        message: preflight.message || 'Approval required',
+                        confirmToken: preflight.challenge,
+                    };
+                    nodeResults[nodeId] = {
+                        status: 'BLOCKED_APPROVAL',
+                        approval,
+                        toolResult: preflight.toolResult,
+                        timing: { lockWaitMs: 0, runMs: 0 },
+                    };
+                    blockedApprovals.push(approval);
+                    return;
+                }
+                if (preflight?.kind === 'denied') {
+                    nodeStates.set(nodeId, 'FAILED');
+                    nodeResults[nodeId] = {
+                        status: 'FAILED',
+                        error: preflight.toolResult?.error,
+                        toolResult: preflight.toolResult,
+                        timing: { lockWaitMs: 0, runMs: 0 },
+                    };
+                    if (plan.policy.failFast)
+                        cancelRemaining();
+                    return;
+                }
+                // 2. Compute Resources (JIT)
+                const resources = node.resources ??
+                    spec.computeResources?.(resolvedArgs, baseCtx) ??
+                    this.deriveDefaultResources(spec, baseCtx);
+                node.resources = resources;
+                // 3. Acquire Locks
+                const mode = lane === 'read' ? 'read' : 'write';
+                const lockStart = Date.now();
+                const lockHandle = await this.locks.acquire(resources, mode, signal);
+                const lockWaitMs = Date.now() - lockStart;
+                const isolatedEnv = spec.concurrency === 'isolated' ? await this.isolation.create() : null;
+                try {
+                    // 4. Execute via Router
+                    const runStart = Date.now();
+                    const result = await this.router.call({
+                        id: nodeId,
+                        phase: baseCtx.phase || 'execute',
+                        toolName: node.toolName,
+                        args: resolvedArgs,
+                        ctx: isolatedEnv
+                            ? { ...baseCtx, env: { ...baseCtx.env, ...isolatedEnv.env } }
+                            : baseCtx,
+                    });
+                    const runMs = Date.now() - runStart;
+                    const timing = { lockWaitMs, runMs };
+                    if (result.status === 'ok') {
+                        nodeStates.set(nodeId, 'SUCCEEDED');
+                        nodeResults[nodeId] = {
+                            status: 'SUCCEEDED',
+                            output: result.output,
+                            toolResult: result,
+                            timing,
+                        };
+                    }
+                    else if (result.status === 'denied' && result.error?.code === 'AUTH_REQUIRED') {
+                        nodeStates.set(nodeId, 'BLOCKED_APPROVAL');
+                        const approval = {
+                            nodeId,
+                            toolName: node.toolName,
+                            riskLevel: spec.riskLevel,
+                            message: result.error.message || 'Approval required',
+                            confirmToken: result.error.confirmToken,
+                        };
+                        nodeResults[nodeId] = {
+                            status: 'BLOCKED_APPROVAL',
+                            approval,
+                            toolResult: result,
+                            timing,
+                        };
+                        blockedApprovals.push(approval);
+                    }
+                    else {
+                        nodeStates.set(nodeId, 'FAILED');
+                        nodeResults[nodeId] = {
+                            status: 'FAILED',
+                            error: result.error,
+                            toolResult: result,
+                            timing,
+                        };
+                        if (plan.policy.failFast)
+                            cancelRemaining();
+                    }
+                }
+                finally {
+                    if (isolatedEnv) {
+                        await isolatedEnv.dispose();
+                    }
+                    lockHandle.release();
+                }
+            }
+            catch (e) {
+                nodeStates.set(nodeId, 'FAILED');
+                const error = e instanceof Error
+                    ? { code: 'EXECUTION_ERROR', message: e.message, stack: e.stack }
+                    : { code: 'EXECUTION_ERROR', message: String(e) };
+                const toolResult = {
+                    id: nodeId,
+                    toolName: node.toolName,
+                    source: 'builtin',
+                    status: 'error',
+                    error: error,
+                };
+                nodeResults[nodeId] = {
+                    status: 'FAILED',
+                    error: error,
+                    toolResult,
+                    timing: { lockWaitMs: 0, runMs: 0 },
+                };
+                if (plan.policy.failFast)
+                    cancelRemaining();
+            }
+            finally {
+                if (lane === 'read')
+                    readRunning--;
+                else if (lane === 'write')
+                    writeRunning--;
+            }
+        };
+        // Main scheduling loop
+        while (!signal.aborted) {
+            updateDeps();
+            let scheduledInThisTick = 0;
+            // If replaying, we strictly follow the recording
+            if (options?.replay) {
+                const nextStep = options.replay.steps[stepCount];
+                if (nextStep) {
+                    const nodeState = nodeStates.get(nextStep.picked);
+                    if (nodeState === 'READY') {
+                        const node = plan.nodes.find((n) => n.id === nextStep.picked);
+                        const lane = getLane(this.tryResolveSpec(node));
+                        if (readRunning + writeRunning < plan.policy.maxParallelism &&
+                            ((lane === 'read' && readRunning < readLimit) ||
+                                (lane === 'write' && writeRunning < writeLimit))) {
+                            const p = startNode(node.id).finally(() => running.delete(p));
+                            running.add(p);
+                            scheduledInThisTick++;
+                            stepCount++; // stepCount is incremented here for replay, or inside startNode for recording
+                        }
+                    }
+                }
+            }
+            else {
+                for (const node of plan.nodes) {
+                    if (nodeStates.get(node.id) !== 'READY')
+                        continue;
+                    const spec = this.tryResolveSpec(node);
+                    const lane = getLane(spec);
+                    if (readRunning + writeRunning >= plan.policy.maxParallelism) {
+                        break;
+                    }
+                    if (lane === 'read' && readRunning < readLimit) {
+                        const p = startNode(node.id).finally(() => running.delete(p));
+                        running.add(p);
+                        scheduledInThisTick++;
+                    }
+                    else if (lane === 'write' && writeRunning < writeLimit) {
+                        const p = startNode(node.id).finally(() => running.delete(p));
+                        running.add(p);
+                        scheduledInThisTick++;
+                    }
+                }
+            }
+            if (scheduledInThisTick === 0) {
+                if (running.size === 0)
+                    break; // All done or blocked
+                await Promise.race(running);
+            }
+        }
+        await Promise.allSettled(running);
+        for (const node of plan.nodes) {
+            if (!nodeResults[node.id]) {
+                nodeResults[node.id] = { status: nodeStates.get(node.id) ?? 'PENDING' };
+            }
+        }
+        const failed = Object.values(nodeResults).some((r) => r.status === 'FAILED');
+        const canceled = Object.values(nodeResults).some((r) => r.status === 'CANCELED');
+        return {
+            planId: plan.id,
+            nodeResults,
+            failed,
+            canceled,
+            blockedApprovals,
+            recording: recordEnabled ? recording : undefined,
+        };
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/core/tools/parser.js

@@ -0,0 +1,89 @@
+import { SalmonError } from '../types/errors.js';
+/**
+ * Custom error for tool parsing failures.
+ */
+export class ToolParseError extends SalmonError {
+    constructor(message) {
+        super(message, 'TOOL_PARSE_ERROR');
+    }
+}
+/**
+ * Strict parser for SalmonLoop Tool Calling Specification v1.1.
+ *
+ * Design Goals:
+ * 1. Prevent "Confused Deputy" by ignoring Markdown code blocks.
+ * 2. Reject ambiguous or multiple tool calls in a single turn.
+ * 3. Enforce strict XML tag structure.
+ */
+export class ToolParser {
+    /**
+     * Parses a model's response text for a tool call.
+     *
+     * @param text The raw response from the LLM.
+     * @returns The parsed tool call, or null if no tool call is found.
+     * @throws ToolParseError if the call is malformed or ambiguous.
+     */
+    parse(text) {
+        if (!text)
+            return null;
+        // 1. Mask markdown code blocks to prevent executing example code
+        const sanitizedText = this.maskCodeBlocks(text);
+        // 2. Security Check: Detect legacy or unauthorized protocols
+        // We strictly ban Claude's <call:tool_name> format to prevent protocol drift.
+        if (/<call:[a-zA-Z0-9_.-]+/.test(sanitizedText)) {
+            throw new ToolParseError('Protocol Violation: Legacy <call:...> format is strictly forbidden. Use <sl_tool_call v="1">.');
+        }
+        // 3. Extract <sl_tool_call v="1"> tags
+        // We use a global match to detect multiple tags (ambiguity)
+        const tagRegex = /<sl_tool_call\s+v="1">([\s\S]*?)<\/sl_tool_call>/g;
+        const matches = Array.from(sanitizedText.matchAll(tagRegex));
+        if (matches.length === 0) {
+            // Basic check: did the model forget the tags but put JSON there?
+            // Or did it use backticks instead of tags?
+            // Specification v1.1 requires strict tags, so we don't try to "fix" it here.
+            return null;
+        }
+        if (matches.length > 1) {
+            throw new ToolParseError('Ambiguous tool call: Multiple <sl_tool_call> tags detected outside of code blocks.');
+        }
+        const rawJson = matches[0][1].trim();
+        if (!rawJson) {
+            throw new ToolParseError('Empty tool call: <sl_tool_call> tag contains no content.');
+        }
+        // 4. Parse JSON content
+        try {
+            const parsed = JSON.parse(rawJson);
+            // Validation of the envelope structure
+            if (!parsed.toolName || typeof parsed.toolName !== 'string') {
+                throw new ToolParseError('Invalid tool call structure: "toolName" field is missing or not a string.');
+            }
+            // Map 'toolName' (protocol v1) to 'tool' (internal)
+            const tool = parsed.toolName;
+            if (parsed.args === undefined) {
+                throw new ToolParseError('Invalid tool call structure: "args" field is missing.');
+            }
+            return {
+                tool,
+                args: parsed.args,
+            };
+        }
+        catch (e) {
+            if (e instanceof ToolParseError)
+                throw e;
+            throw new ToolParseError(`Failed to parse tool call JSON: ${e.message}`);
+        }
+    }
+    /**
+     * Replaces the content of Markdown code blocks with whitespace of equal length.
+     * This ensures regex matches for tags won't trigger inside code blocks,
+     * while preserving character offsets if we ever need them for errors.
+     */
+    maskCodeBlocks(text) {
+        // Fenced code blocks
+        let masked = text.replace(/```[\s\S]*?```/g, (match) => ' '.repeat(match.length));
+        // Inline code blocks (single backticks) - also mask these just in case
+        masked = masked.replace(/`[^`\n]+`/g, (match) => ' '.repeat(match.length));
+        return masked;
+    }
+}
+//# sourceMappingURL=parser.js.map