salmon-loop 0.2.3

package/dist/core/protocols/a2a/sdk/executor.js

@@ -0,0 +1,301 @@
+import { InMemoryTaskStore } from '@a2a-js/sdk/server';
+export function createA2AInteractionExecutor(deps) {
+    const store = deps.taskStore ?? new InMemoryTaskStore();
+    const metadataByTaskId = new Map();
+    const cancelledTaskIds = new Set();
+    const COMPLETION_GRACE_PERIOD_MS = 1500;
+    const cleanupByTaskId = new Map();
+    const submittedPublished = new Set();
+    // Prevents duplicate terminal status events when publishTaskStatus is called multiple times
+    const terminalPublished = new Set();
+    return {
+        async execute(requestContext, executionEventBus) {
+            const capability = deps.capabilityResolver?.(requestContext.userMessage) ?? 'patch';
+            const pendingEvents = [];
+            let resolvedTaskId = null;
+            let cleanedUp = false;
+            const unsubscribe = deps.taskEventBus.subscribe((event) => {
+                if (!resolvedTaskId) {
+                    pendingEvents.push(event);
+                    return;
+                }
+                if (event.taskId === resolvedTaskId) {
+                    void handleTaskEvent(event);
+                }
+            });
+            const cleanup = () => {
+                if (!cleanedUp) {
+                    unsubscribe();
+                    cleanedUp = true;
+                    if (resolvedTaskId) {
+                        cleanupByTaskId.delete(resolvedTaskId);
+                    }
+                }
+            };
+            const handleTaskEvent = async (_event) => {
+                if (!resolvedTaskId)
+                    return;
+                const isFinal = await publishTaskStatus(resolvedTaskId, executionEventBus);
+                if (isFinal) {
+                    finalizeTask(resolvedTaskId, executionEventBus);
+                }
+            };
+            try {
+                const { task } = await deps.facade.createTask({
+                    capability,
+                    request: { instruction: extractInstruction(requestContext.userMessage) },
+                    // Pass SDK's taskId to facade to ensure consistency with eventBusManager
+                    taskId: requestContext.taskId,
+                });
+                resolvedTaskId = task.id;
+                cleanupByTaskId.set(task.id, cleanup);
+                metadataByTaskId.set(task.id, {
+                    contextId: requestContext.userMessage.contextId ?? requestContext.contextId,
+                    message: requestContext.userMessage,
+                    capability,
+                });
+                for (const event of pendingEvents) {
+                    if (event.taskId === resolvedTaskId) {
+                        await handleTaskEvent(event);
+                    }
+                }
+            }
+            catch (error) {
+                cleanup();
+                throw error;
+            }
+        },
+        async cancelTask(taskId, cancelEventBus) {
+            cancelledTaskIds.add(taskId);
+            await deps.facade.cancelTask(taskId);
+            const isFinal = await publishTaskStatus(taskId, cancelEventBus);
+            if (isFinal) {
+                finalizeTask(taskId, cancelEventBus);
+            }
+        },
+    };
+    async function publishTaskStatus(taskId, eventBus) {
+        const metadata = metadataByTaskId.get(taskId);
+        if (!metadata)
+            return false;
+        const envelope = await deps.facade.getTask(taskId);
+        if (!envelope)
+            return false;
+        // Build status from task state
+        const currentState = mapState(envelope.state);
+        // ALWAYS publish "submitted" first if not yet published
+        if (!submittedPublished.has(taskId)) {
+            submittedPublished.add(taskId);
+            const submittedStatus = {
+                state: 'submitted',
+                timestamp: envelope.createdAt ?? new Date().toISOString(),
+                message: undefined,
+            };
+            const submittedUpdate = {
+                kind: 'status-update',
+                taskId: envelope.id,
+                contextId: metadata.contextId,
+                status: submittedStatus,
+                final: false,
+                metadata: { attempt: envelope.attempt },
+            };
+            eventBus.publish(submittedUpdate);
+            // Save as 'running' state (not completed) to keep task cancelable during grace period.
+            // SDK rejects cancellation if task is already in terminal state in the store.
+            const submittedEnvelope = { ...envelope, state: 'running' };
+            const snapshot = buildTaskSnapshot(submittedEnvelope, metadata);
+            await store.save(snapshot);
+            // If the current state is still "submitted", we're done
+            if (currentState === 'submitted') {
+                return false;
+            }
+            // Otherwise, continue to publish the actual current state
+        }
+        // If terminal status already published, don't publish again
+        if (terminalPublished.has(taskId)) {
+            return true;
+        }
+        // For "completed" state, apply grace period and check for cancellation.
+        // This prevents race condition where "completed" is published before cancellation arrives.
+        if (currentState === 'completed') {
+            if (cancelledTaskIds.has(taskId)) {
+                terminalPublished.add(taskId);
+                const canceledEnvelope = { ...envelope, state: 'cancelled' };
+                const snapshot = buildTaskSnapshot(canceledEnvelope, metadata);
+                await store.save(snapshot);
+                const status = {
+                    ...buildTaskStatus(envelope, metadata.contextId),
+                    state: 'canceled',
+                };
+                const update = {
+                    kind: 'status-update',
+                    taskId: envelope.id,
+                    contextId: metadata.contextId,
+                    status,
+                    final: true,
+                    metadata: { attempt: envelope.attempt },
+                };
+                eventBus.publish(update);
+                return true;
+            }
+            // Grace period allows cancellation to arrive before publishing "completed"
+            await delay(COMPLETION_GRACE_PERIOD_MS);
+            // Check both executor state and store state to detect cancellation.
+            // SDK may cancel directly in store if eventBus is unavailable.
+            const taskAfterGrace = await store.load(taskId);
+            const wasCancelled = cancelledTaskIds.has(taskId) || taskAfterGrace?.status.state === 'canceled';
+            if (wasCancelled) {
+                terminalPublished.add(taskId);
+                if (taskAfterGrace?.status.state !== 'canceled') {
+                    const canceledEnvelope = { ...envelope, state: 'cancelled' };
+                    const snapshot = buildTaskSnapshot(canceledEnvelope, metadata);
+                    await store.save(snapshot);
+                }
+                const status = {
+                    ...buildTaskStatus(envelope, metadata.contextId),
+                    state: 'canceled',
+                };
+                const update = {
+                    kind: 'status-update',
+                    taskId: envelope.id,
+                    contextId: metadata.contextId,
+                    status,
+                    final: true,
+                    metadata: { attempt: envelope.attempt },
+                };
+                eventBus.publish(update);
+                return true;
+            }
+            // No cancellation detected, safe to publish "completed"
+            terminalPublished.add(taskId);
+            const snapshot = buildTaskSnapshot(envelope, metadata);
+            await store.save(snapshot);
+            const status = buildTaskStatus(envelope, metadata.contextId);
+            const update = {
+                kind: 'status-update',
+                taskId: envelope.id,
+                contextId: metadata.contextId,
+                status,
+                final: true,
+                metadata: { attempt: envelope.attempt },
+            };
+            eventBus.publish(update);
+            return true;
+        }
+        // For all other states (working, failed, canceled, etc.), save and publish immediately
+        const snapshot = buildTaskSnapshot(envelope, metadata);
+        await store.save(snapshot);
+        const status = buildTaskStatus(envelope, metadata.contextId);
+        const isFinal = isTerminalState(status.state);
+        if (isFinal) {
+            terminalPublished.add(taskId);
+        }
+        const update = {
+            kind: 'status-update',
+            taskId: envelope.id,
+            contextId: metadata.contextId,
+            status,
+            final: isFinal,
+            metadata: { attempt: envelope.attempt },
+        };
+        eventBus.publish(update);
+        return isFinal;
+    }
+    function finalizeTask(taskId, eventBus) {
+        eventBus.finished();
+        metadataByTaskId.delete(taskId);
+        const cleanup = cleanupByTaskId.get(taskId);
+        if (cleanup) {
+            cleanup();
+        }
+        cleanupByTaskId.delete(taskId);
+        cancelledTaskIds.delete(taskId);
+        submittedPublished.delete(taskId);
+        terminalPublished.delete(taskId);
+    }
+    function extractInstruction(message) {
+        const textParts = message.parts
+            .filter((part) => part.kind === 'text')
+            .map((part) => part.text.trim())
+            .filter(Boolean);
+        return textParts.join('\n') || 'Run task';
+    }
+    function delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    function mapState(state) {
+        switch (state) {
+            case 'accepted':
+                return 'submitted';
+            case 'running':
+            case 'streaming':
+                return 'working';
+            case 'awaiting_input':
+                return 'input-required';
+            case 'completed':
+                return 'completed';
+            case 'failed':
+                return 'failed';
+            case 'cancelled':
+                return 'canceled';
+            default:
+                return 'unknown';
+        }
+    }
+    function isTerminalState(state) {
+        return (state === 'completed' || state === 'failed' || state === 'canceled' || state === 'rejected');
+    }
+    function buildTaskStatus(envelope, contextId) {
+        return {
+            state: mapState(envelope.state),
+            timestamp: envelope.createdAt ?? new Date().toISOString(),
+            message: buildStatusMessage(envelope, contextId),
+        };
+    }
+    function buildStatusMessage(envelope, contextId) {
+        const text = envelope.statusMessage ?? envelope.failure?.message ?? envelope.inputRequired?.prompt;
+        if (!text)
+            return undefined;
+        return {
+            kind: 'message',
+            messageId: `status-${envelope.id}-${Date.now()}`,
+            role: 'agent',
+            contextId,
+            parts: [
+                {
+                    kind: 'text',
+                    text,
+                },
+            ],
+        };
+    }
+    function buildTaskSnapshot(envelope, metadata) {
+        return {
+            id: envelope.id,
+            kind: 'task',
+            contextId: metadata.contextId,
+            history: [metadata.message],
+            metadata: {
+                capability: envelope.capability,
+                attempt: envelope.attempt,
+            },
+            artifacts: convertArtifacts(envelope.artifacts),
+            status: buildTaskStatus(envelope, metadata.contextId),
+        };
+    }
+    function convertArtifacts(artifacts) {
+        if (!artifacts || artifacts.length === 0)
+            return undefined;
+        return artifacts.map((artifact) => ({
+            artifactId: artifact.id,
+            name: artifact.name,
+            parts: [
+                {
+                    kind: 'text',
+                    text: artifact.content ?? artifact.name ?? '',
+                },
+            ],
+        }));
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/core/protocols/a2a/sdk/server.js

@@ -0,0 +1,24 @@
+import { DefaultRequestHandler, InMemoryTaskStore, } from '@a2a-js/sdk/server';
+import { agentCardHandler, jsonRpcHandler, UserBuilder, } from '@a2a-js/sdk/server/express';
+import express from 'express';
+export function createA2ASdkExpressApp(options) {
+    const store = options.taskStore ?? new InMemoryTaskStore();
+    const requestHandler = new DefaultRequestHandler(options.agentCard, store, options.agentExecutor);
+    const userBuilder = options.userBuilder ?? ((_) => UserBuilder.noAuthentication());
+    const app = express();
+    app.disable('x-powered-by');
+    app.use(express.json());
+    const agentCardPath = options.agentCardPath ?? '/.well-known/agent-card.json';
+    app.use(agentCardPath, agentCardHandler({
+        agentCardProvider: () => requestHandler.getAgentCard(),
+    }));
+    const rpcPath = options.rpcPath ?? '/a2a/jsonrpc';
+    const router = express.Router();
+    if (options.authMiddleware) {
+        router.use(options.authMiddleware);
+    }
+    router.use(jsonRpcHandler({ requestHandler, userBuilder }));
+    app.use(rpcPath, router);
+    return app;
+}
+//# sourceMappingURL=server.js.map

package/dist/core/protocols/a2a/task-projection.js

@@ -0,0 +1,45 @@
+function projectTaskState(state) {
+    if (state === 'accepted')
+        return 'submitted';
+    if (state === 'running' || state === 'streaming')
+        return 'working';
+    if (state === 'awaiting_input')
+        return 'input-required';
+    if (state === 'completed')
+        return 'completed';
+    if (state === 'failed')
+        return 'failed';
+    if (state === 'cancelled')
+        return 'canceled';
+    return 'working';
+}
+export function projectCanonicalTaskToA2ATask(task) {
+    return {
+        id: task.id,
+        state: task.state,
+        status: {
+            state: projectTaskState(task.state),
+            timestamp: task.createdAt ?? new Date().toISOString(),
+            message: task.statusMessage,
+        },
+        failure: task.failure,
+        requiredAction: task.inputRequired,
+        artifacts: (task.artifacts ?? []).map((artifact) => ({
+            artifactId: artifact.id,
+            name: artifact.name,
+            kind: artifact.kind,
+            mimeType: artifact.mimeType,
+            content: artifact.content,
+            delivery: artifact.delivery,
+            handle: artifact.handle,
+            url: artifact.url,
+            expiresAt: artifact.expiresAt,
+        })),
+        metadata: {
+            capability: task.capability,
+            tenantId: task.tenantId,
+            attempt: task.attempt,
+        },
+    };
+}
+//# sourceMappingURL=task-projection.js.map

package/dist/core/protocols/acp/acp-command-runner.js

@@ -0,0 +1,204 @@
+function sleep(ms) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createFailure(input, params) {
+    return {
+        command: input.command,
+        args: input.args ?? [],
+        ...params,
+    };
+}
+function finalizeResult(params) {
+    const { input } = params;
+    let failure;
+    if (params.error) {
+        failure = createFailure(input, {
+            kind: 'spawn_error',
+            message: params.error.message,
+            code: params.error.code,
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.aborted) {
+        failure = createFailure(input, {
+            kind: 'aborted',
+            message: 'Command aborted',
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.timedOut) {
+        failure = createFailure(input, {
+            kind: 'timeout',
+            message: 'Command timed out',
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    else if (params.code !== 0) {
+        failure = createFailure(input, {
+            kind: 'nonzero_exit',
+            message: `Command exited with code ${String(params.code)}`,
+            exitCode: params.code,
+            signal: params.signal,
+        });
+    }
+    return {
+        code: params.code,
+        signal: params.signal,
+        timedOut: params.timedOut,
+        aborted: params.aborted,
+        error: params.error,
+        failure,
+        stdout: params.stdout,
+        stderr: params.stderr,
+        stdoutTruncated: params.stdoutTruncated,
+        stderrTruncated: params.stderrTruncated,
+    };
+}
+function computeOutputByteLimit(input) {
+    const stdoutLimit = input.maxStdoutBytes ?? null;
+    const stderrLimit = input.maxStderrBytes ?? null;
+    const candidates = [stdoutLimit, stderrLimit].filter((value) => typeof value === 'number' && Number.isFinite(value) && value > 0);
+    if (candidates.length === 0)
+        return null;
+    // ACP terminal output is a single combined buffer; use the larger budget.
+    return Math.max(...candidates);
+}
+async function safeRelease(terminal) {
+    try {
+        await terminal.release();
+    }
+    catch {
+        // Ignore release errors.
+    }
+}
+export function createAcpCommandRunner(params) {
+    const pollIntervalMs = params.pollIntervalMs ?? 10;
+    return {
+        async isCommandAvailable() {
+            // Platform detection is host-specific and not part of ACP capabilities.
+            // In strict hosted mode we rely on real execution results.
+            return true;
+        },
+        async spawnCommand(input) {
+            let terminal = null;
+            let stdout = '';
+            let stdoutTruncated = false;
+            const stderr = '';
+            const stderrTruncated = false;
+            let timedOut = false;
+            let aborted = Boolean(input.signal?.aborted);
+            let code = null;
+            let signal = null;
+            const start = Date.now();
+            const timeoutMs = typeof input.timeoutMs === 'number' &&
+                Number.isFinite(input.timeoutMs) &&
+                input.timeoutMs > 0
+                ? input.timeoutMs
+                : null;
+            function emitDelta(next) {
+                if (next === stdout)
+                    return;
+                if (next.startsWith(stdout)) {
+                    const delta = next.slice(stdout.length);
+                    if (delta)
+                        input.onStdoutChunk?.(Buffer.from(delta, 'utf8'));
+                    stdout = next;
+                    return;
+                }
+                // Output was truncated/rotated by the host; emit the whole buffer as a reset.
+                input.onStdoutChunk?.(Buffer.from(next, 'utf8'));
+                stdout = next;
+            }
+            try {
+                const env = input.env
+                    ? Object.entries(input.env)
+                        .filter(([, value]) => value !== undefined)
+                        .map(([name, value]) => ({ name, value: String(value) }))
+                    : undefined;
+                terminal = await params.conn.createTerminal({
+                    sessionId: params.sessionId,
+                    command: input.command,
+                    args: input.args ?? [],
+                    cwd: input.cwd ?? undefined,
+                    env,
+                    outputByteLimit: computeOutputByteLimit(input),
+                });
+                while (true) {
+                    aborted = aborted || Boolean(input.signal?.aborted);
+                    if (aborted) {
+                        try {
+                            await terminal.kill();
+                        }
+                        catch {
+                            // Ignore kill errors.
+                        }
+                        break;
+                    }
+                    if (timeoutMs !== null && Date.now() - start > timeoutMs) {
+                        timedOut = true;
+                        try {
+                            await terminal.kill();
+                        }
+                        catch {
+                            // Ignore kill errors.
+                        }
+                        break;
+                    }
+                    const out = await terminal.currentOutput();
+                    emitDelta(out.output);
+                    stdoutTruncated = stdoutTruncated || Boolean(out.truncated);
+                    if (out.exitStatus) {
+                        code = out.exitStatus.exitCode ?? null;
+                        signal = (out.exitStatus.signal ?? null);
+                        break;
+                    }
+                    await sleep(pollIntervalMs);
+                }
+                if (code === null && !timedOut && !aborted) {
+                    const exit = await terminal.waitForExit();
+                    code = exit.exitCode ?? null;
+                    signal = (exit.signal ?? null);
+                    const out = await terminal.currentOutput();
+                    emitDelta(out.output);
+                    stdoutTruncated = stdoutTruncated || Boolean(out.truncated);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return finalizeResult({
+                    input,
+                    stdout,
+                    stderr,
+                    code,
+                    signal,
+                    timedOut,
+                    aborted,
+                    stdoutTruncated,
+                    stderrTruncated,
+                    error: { message },
+                });
+            }
+            finally {
+                if (terminal)
+                    await safeRelease(terminal);
+            }
+            return finalizeResult({
+                input,
+                stdout,
+                stderr,
+                code,
+                signal,
+                timedOut,
+                aborted,
+                stdoutTruncated,
+                stderrTruncated,
+            });
+        },
+    };
+}
+//# sourceMappingURL=acp-command-runner.js.map

package/dist/core/protocols/acp/acp-filesystem.js

@@ -0,0 +1,43 @@
+function isResourceNotFoundError(error) {
+    if (!error || (typeof error !== 'object' && typeof error !== 'function'))
+        return false;
+    const code = error.code;
+    return code === -32002;
+}
+export function createAcpFileSystem(params) {
+    return {
+        async readFile(path, _encoding) {
+            const result = await params.conn.readTextFile({
+                sessionId: params.sessionId,
+                path,
+            });
+            return result.content;
+        },
+        async writeFile(path, content) {
+            await params.conn.writeTextFile({
+                sessionId: params.sessionId,
+                path,
+                content,
+            });
+        },
+        async exists(path) {
+            try {
+                // Use minimal limit to check existence without transferring full content
+                await params.conn.readTextFile({ sessionId: params.sessionId, path, line: 1, limit: 1 });
+                return true;
+            }
+            catch (error) {
+                if (isResourceNotFoundError(error))
+                    return false;
+                throw error;
+            }
+        },
+        async mkdir(_path, _options) {
+            // ACP formal FS methods are currently file-based; explicit directory creation
+            // is usually handled implicitly by the host during writeTextFile().
+            // This is a no-op to satisfy the interface while avoiding non-standard extensions.
+            return;
+        },
+    };
+}
+//# sourceMappingURL=acp-filesystem.js.map

package/dist/core/protocols/acp/checkpoint-meta.js

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