salmon-loop 0.2.16 → 0.3.0

package/dist/cli/commands/serve.js

@@ -1,5 +1,5 @@
 import { normalizePermissionMode } from '../../core/config/index.js';
-import { buildA2AAgentCard, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, PlainReporter, PluginLoader, resolveExtensions, resolveExecutionProfile, runSalmonLoop, setPluginRegistry, setPromptRegistry, startAcpStdioServer, StderrReporter, } from '../../core/facades/cli-serve.js';
+import { buildA2AAgentCard, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, mergeResolvedExtensions, PACKAGE_VERSION, PlainReporter, PluginLoader, resolveExtensions, resolveExecutionProfile, runSalmonLoop, setPluginRegistry, setPromptRegistry, startAcpStdioServer, StderrReporter, } from '../../core/facades/cli-serve.js';
 import { selectPublicCapabilitiesForSurface, toA2APublicSkills, } from '../../core/public-capabilities/projections.js';
 import { buildPublicCapabilityRegistry } from '../../core/public-capabilities/registry.js';
 import { createTerminalAuthorizationProvider } from '../authorization/provider.js';
@@ -124,7 +124,7 @@ export async function handleServeCommand(_options, command) {
         forceNonInteractive: true,
     });
     const executor = createSalmonTaskExecutor({
-        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, }) => {
+        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, extensions: taskExtensions, }) => {
             const effectiveRepoPath = repoPath ?? defaultRepoPath;
             const flowMode = mode;
             const executionDefaults = buildServeLoopExecutionDefaults(flowMode);
@@ -151,7 +151,7 @@ export async function handleServeCommand(_options, command) {
                 fileSystemOverride,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,
-                extensions: extensions.resolved,
+                extensions: mergeResolvedExtensions(extensions.resolved, taskExtensions),
                 onEvent,
                 signal,
             });
@@ -199,7 +199,7 @@ export async function handleServeCommand(_options, command) {
     if (acpStdioEnabled) {
         startAcpStdioServer((conn) => createAcpFormalAgent({
             conn,
-            agentInfo: { name: 'salmon-loop', version: '0.2.0' },
+            agentInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
             defaultModeId: 'autopilot',
             defaultPermissionPolicy: resolveDefaultAcpPermissionPolicy(defaultPermissionMode),
             checkpointReader: {
@@ -280,7 +280,7 @@ export async function handleServeAcpCommand(_options, command) {
         forceNonInteractive: true,
     });
     const executor = createSalmonTaskExecutor({
-        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, }) => {
+        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, extensions: taskExtensions, }) => {
             const effectiveRepoPath = repoPath ?? defaultRepoPath;
             const flowMode = mode;
             const executionDefaults = buildServeLoopExecutionDefaults(flowMode);
@@ -306,7 +306,7 @@ export async function handleServeAcpCommand(_options, command) {
                 languagePlugins,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,
-                extensions: extensions.resolved,
+                extensions: mergeResolvedExtensions(extensions.resolved, taskExtensions),
                 onEvent,
                 signal,
             });
@@ -325,7 +325,7 @@ export async function handleServeAcpCommand(_options, command) {
     });
     startAcpStdioServer((conn) => createAcpFormalAgent({
         conn,
-        agentInfo: { name: 'salmon-loop', version: '0.2.0' },
+        agentInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
         defaultModeId: 'autopilot',
         defaultPermissionPolicy: resolveDefaultAcpPermissionPolicy(defaultPermissionMode),
         checkpointReader: {

package/dist/cli/program-bootstrap.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
-import { initializeRuntime } from '../core/facades/cli-program-bootstrap.js';
+import { initializeRuntime, PACKAGE_VERSION } from '../core/facades/cli-program-bootstrap.js';
 import { text } from './locales/index.js';
 export function bootstrapProgram(options = {}) {
     initializeRuntime();
@@ -17,7 +17,7 @@ export function bootstrapProgram(options = {}) {
         .name('s8p')
         .alias('salmonloop')
         .description(text.cli.programDescription)
-        .version('0.2.0')
+        .version(PACKAGE_VERSION)
         .addHelpText('after', text.cli.programHelpFooter);
     return program;
 }

package/dist/core/backends/salmon-loop/task-executor.js

@@ -31,6 +31,7 @@ export function createSalmonTaskExecutor(deps) {
                     authorizationProvider: options?.authorizationProvider,
                     authorizationMode: options?.authorizationMode,
                     fileSystemOverride: options?.fileSystemOverride,
+                    extensions: task.request.extensions,
                 });
             });
             if (result.reasonCode === 'AWAITING_INPUT' && result.inputRequired) {

package/dist/core/extensions/merge.js

@@ -26,4 +26,18 @@ export function mergeScopedEntries(user, repo) {
     }
     return Array.from(merged.values());
 }
+export function mergeResolvedExtensions(base, overlay) {
+    if (!overlay)
+        return base;
+    return {
+        mcpServers: [...base.mcpServers, ...overlay.mcpServers],
+        toolPlugins: [...base.toolPlugins, ...overlay.toolPlugins],
+        skillDiscovery: {
+            scope: overlay.skillDiscovery.paths.length > 0
+                ? overlay.skillDiscovery.scope
+                : base.skillDiscovery.scope,
+            paths: [...base.skillDiscovery.paths, ...overlay.skillDiscovery.paths],
+        },
+    };
+}
 //# sourceMappingURL=merge.js.map

package/dist/core/facades/cli-program-bootstrap.js

@@ -1,2 +1,3 @@
 export { initializeRuntime } from '../runtime/initialize.js';
+export { PACKAGE_VERSION } from '../version.js';
 //# sourceMappingURL=cli-program-bootstrap.js.map

package/dist/core/facades/cli-serve.js

@@ -2,6 +2,7 @@ export { createSalmonTaskExecutor } from '../backends/salmon-loop/task-executor.
 export { GitSnapshotCheckpointService } from '../checkpoint-domain/service.js';
 export { resolveConfig } from '../config/resolve.js';
 export { resolveExtensions } from '../extensions/index.js';
+export { mergeResolvedExtensions } from '../extensions/merge.js';
 export { createTaskEventBus } from '../interaction/events/bus.js';
 export { createInteractionFacade } from '../interaction/orchestration/facade.js';
 export { getLogger, PlainReporter, StderrReporter } from '../observability/logger.js';
@@ -16,4 +17,5 @@ export { createAgentServerRuntime } from '../runtime/agent-server-runtime.js';
 export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { runSalmonLoop } from '../runtime/loop.js';
 export { getUserAcpSessionStorePath } from '../runtime/paths.js';
+export { PACKAGE_VERSION } from '../version.js';
 //# sourceMappingURL=cli-serve.js.map

package/dist/core/interaction/orchestration/facade.js

@@ -20,7 +20,7 @@ export function createInteractionFacade(deps) {
                 id: input.taskId ?? `task_${Date.now()}`,
                 capability: input.capability,
                 state: 'accepted',
-                request: input.request,
+                request: { ...input.request, extensions: input.extensions },
                 createdAt: new Date().toISOString(),
                 attempt: 1,
             };

package/dist/core/llm/ai-sdk/request-params.js

@@ -65,10 +65,49 @@ function resolveResponseFormat(options) {
     }
     return undefined;
 }
+function stringifySystemContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (content === undefined || content === null)
+        return '';
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (isRecord(part) && typeof part.text === 'string')
+                return part.text;
+            return '';
+        })
+            .filter((part) => part.length > 0)
+            .join('\n');
+    }
+    return String(content);
+}
+function splitSystemMessages(messages) {
+    const systemParts = [];
+    const conversationMessages = [];
+    for (const message of messages) {
+        if (isRecord(message) && message.role === 'system') {
+            const content = stringifySystemContent(message.content).trim();
+            if (content) {
+                systemParts.push(content);
+            }
+            continue;
+        }
+        conversationMessages.push(message);
+    }
+    return {
+        system: systemParts.length > 0 ? systemParts.join('\n\n') : undefined,
+        messages: conversationMessages,
+    };
+}
 export function buildAiSdkRequestParams(params) {
+    const splitMessages = splitSystemMessages(params.messages);
     return {
         model: params.model,
-        messages: params.messages,
+        system: splitMessages.system,
+        messages: splitMessages.messages,
         tools: params.tools,
         temperature: params.options.temperature,
         maxOutputTokens: params.options.maxTokens != null ? Number(params.options.maxTokens) : undefined,

package/dist/core/protocols/a2a/agent-card.js

@@ -1,3 +1,4 @@
+import { PACKAGE_VERSION } from '../../version.js';
 export function buildA2AAgentCard(input) {
     const capabilities = input.capabilities ?? [];
     const securitySchemes = input.security.length > 0
@@ -10,7 +11,7 @@ export function buildA2AAgentCard(input) {
         name: input.name,
         url: input.url,
         description: input.description ?? 'Salmon Loop agent',
-        version: input.version ?? '0.2.0',
+        version: input.version ?? PACKAGE_VERSION,
         protocolVersion: input.protocolVersion ?? '1.0.0',
         defaultInputModes: ['text/plain'],
         defaultOutputModes: ['text/plain'],

package/dist/core/protocols/acp/formal-agent.js

@@ -103,6 +103,21 @@ function formatResourceLink(block) {
     const description = block.description ? ` - ${block.description}` : '';
     return `Resource: ${title} (${block.uri})${description}`;
 }
+function formatEmbeddedResource(block) {
+    const resource = block.resource;
+    const uri = typeof resource.uri === 'string' ? resource.uri : 'embedded-resource';
+    const mimeType = typeof resource.mimeType === 'string' ? resource.mimeType : undefined;
+    if (typeof resource.text === 'string') {
+        const header = mimeType
+            ? `Embedded resource: ${uri} (${mimeType})`
+            : `Embedded resource: ${uri}`;
+        return `${header}\n${resource.text}`;
+    }
+    const header = mimeType
+        ? `Embedded binary resource: ${uri} (${mimeType})`
+        : `Embedded binary resource: ${uri}`;
+    return header;
+}
 function extractTextFromPrompt(prompt, capabilities) {
     const parts = [];
     for (const block of prompt) {
@@ -127,6 +142,7 @@ function extractTextFromPrompt(prompt, capabilities) {
                 if (!capabilities.embeddedContext) {
                     throw new RequestError(-32000, 'Prompt content type resource is not supported');
                 }
+                parts.push(formatEmbeddedResource(block));
                 break;
             default:
                 throw new RequestError(-32602, 'Invalid params: unsupported content block type');
@@ -450,6 +466,74 @@ function buildPlanUpdateFromCoreIfChanged(read, state) {
         entries,
     };
 }
+function envListToRecord(env) {
+    const record = {};
+    for (const entry of env) {
+        record[entry.name] = entry.value;
+    }
+    return record;
+}
+function headersListToRecord(headers) {
+    const record = {};
+    for (const entry of headers) {
+        record[entry.name] = entry.value;
+    }
+    return record;
+}
+function acpMcpServersToResolved(mcpServers) {
+    if (!Array.isArray(mcpServers))
+        return [];
+    const resolved = [];
+    for (const server of mcpServers) {
+        const transportType = 'type' in server ? server.type : 'stdio';
+        if (transportType === 'sse' || transportType === 'acp') {
+            throw new RequestError(-32602, `Invalid params: unsupported MCP server transport "${transportType}"`);
+        }
+        if ('type' in server && server.type === 'http') {
+            const httpServer = server;
+            resolved.push({
+                name: httpServer.name,
+                enabled: true,
+                transport: 'http',
+                url: httpServer.url,
+                headers: headersListToRecord(httpServer.headers),
+                allowTools: ['*'],
+                allowResources: [],
+                scope: 'repo',
+            });
+            continue;
+        }
+        if (transportType !== 'stdio') {
+            throw new RequestError(-32602, `Invalid params: unsupported MCP server transport "${transportType}"`);
+        }
+        const stdioServer = server;
+        resolved.push({
+            name: stdioServer.name,
+            enabled: true,
+            transport: 'stdio',
+            command: stdioServer.command,
+            args: stdioServer.args,
+            env: envListToRecord(stdioServer.env),
+            allowTools: ['*'],
+            allowResources: [],
+            scope: 'repo',
+        });
+    }
+    return resolved;
+}
+function acpMcpServersToExtensions(mcpServers) {
+    const resolvedServers = acpMcpServersToResolved(mcpServers);
+    if (resolvedServers.length === 0)
+        return undefined;
+    return {
+        mcpServers: resolvedServers,
+        toolPlugins: [],
+        skillDiscovery: { paths: [], scope: 'repo' },
+    };
+}
+function validateAcpMcpServers(mcpServers) {
+    void acpMcpServersToResolved(mcpServers);
+}
 function extractSlashInput(prompt) {
     if (prompt.length !== 1)
         return null;
@@ -505,8 +589,9 @@ export function createAcpFormalAgent(deps) {
         embeddedContext: deps.capabilityPolicy?.promptCapabilities?.embeddedContext ?? false,
     };
     const mcpCapabilities = {
-        http: deps.capabilityPolicy?.mcpCapabilities?.http ?? false,
+        http: deps.capabilityPolicy?.mcpCapabilities?.http ?? true,
         sse: deps.capabilityPolicy?.mcpCapabilities?.sse ?? false,
+        acp: deps.capabilityPolicy?.mcpCapabilities?.acp ?? false,
     };
     const sessionPersistencePath = deps.sessionPersistencePath;
     const sessionStorePolicy = {
@@ -520,6 +605,7 @@ export function createAcpFormalAgent(deps) {
     const executionBinding = deps.executionBinding ?? 'local';
     let sessionsHydrated = false;
     let hydratePromise = null;
+    const deletedSessionIds = new Map();
     function parseTimestamp(value) {
         if (typeof value !== 'string' || value.length === 0)
             return 0;
@@ -533,6 +619,31 @@ export function createAcpFormalAgent(deps) {
             .sort((a, b) => parseTimestamp(b.updatedAt) - parseTimestamp(a.updatedAt))
             .slice(0, sessionStorePolicy.maxEntries);
     }
+    function normalizeDeletedSessionRecords(input) {
+        if (!Array.isArray(input))
+            return [];
+        const byId = new Map();
+        for (const entry of input) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            if (typeof record.id !== 'string' || !record.id)
+                continue;
+            if (typeof record.deletedAt !== 'string' || !record.deletedAt)
+                continue;
+            const current = byId.get(record.id);
+            if (!current || parseTimestamp(record.deletedAt) > parseTimestamp(current.deletedAt)) {
+                byId.set(record.id, { id: record.id, deletedAt: record.deletedAt });
+            }
+        }
+        return Array.from(byId.values());
+    }
+    function pruneDeletedSessionRecords(records) {
+        const cutoff = Date.now() - sessionStorePolicy.maxAgeMs;
+        return normalizeDeletedSessionRecords(records)
+            .filter((record) => parseTimestamp(record.deletedAt) >= cutoff)
+            .sort((a, b) => parseTimestamp(b.deletedAt) - parseTimestamp(a.deletedAt));
+    }
     function normalizePersistedSessionStore(input) {
         if (!input || typeof input !== 'object') {
             return { schemaVersion: 2, sessions: [] };
@@ -557,10 +668,15 @@ export function createAcpFormalAgent(deps) {
                         : ACP_PERMISSION_POLICY_ASK,
                     modeId: resolveExposedAcpModeId(deps.defaultModeId),
                 })),
+                deletedSessions: [],
             };
         }
         if (raw.schemaVersion === 2) {
-            return { schemaVersion: 2, sessions: raw.sessions };
+            return {
+                schemaVersion: 2,
+                sessions: raw.sessions,
+                deletedSessions: pruneDeletedSessionRecords(raw.deletedSessions),
+            };
         }
         return { schemaVersion: 2, sessions: [] };
     }
@@ -616,6 +732,7 @@ export function createAcpFormalAgent(deps) {
             }
         }
         const payload = { schemaVersion: 2, sessions: prunedRecords };
+        const payloadDeletedSessions = pruneDeletedSessionRecords(Array.from(deletedSessionIds, ([id, deletedAt]) => ({ id, deletedAt })));
         const primaryRepoPath = prunedRecords[0]?.cwd;
         const lockAuditDetails = {
             lockPath,
@@ -699,13 +816,24 @@ export function createAcpFormalAgent(deps) {
                     // ignore read failure; writing fresh payload is acceptable
                 }
                 const merged = new Map();
+                const mergedDeletedSessions = pruneDeletedSessionRecords([
+                    ...(existing.deletedSessions ?? []),
+                    ...payloadDeletedSessions,
+                ]);
+                const mergedDeletedIds = new Set(mergedDeletedSessions.map((record) => record.id));
+                for (const record of mergedDeletedSessions) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
                 for (const entry of existing.sessions)
                     merged.set(entry.id, entry);
                 for (const entry of payload.sessions)
                     merged.set(entry.id, entry);
+                for (const id of mergedDeletedIds)
+                    merged.delete(id);
                 const mergedPayload = {
                     schemaVersion: 2,
                     sessions: pruneSessionRecords(Array.from(merged.values())),
+                    deletedSessions: mergedDeletedSessions,
                 };
                 await writeFile(tempPath, JSON.stringify(mergedPayload, null, 2), 'utf8');
                 await rename(tempPath, sessionPersistencePath);
@@ -748,7 +876,13 @@ export function createAcpFormalAgent(deps) {
             try {
                 const raw = await readFile(sessionPersistencePath, 'utf8');
                 const parsed = normalizePersistedSessionStore(JSON.parse(raw));
+                const deletedIds = new Set(parsed.deletedSessions?.map((record) => record.id) ?? []);
+                for (const record of parsed.deletedSessions ?? []) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
                 for (const stored of pruneSessionRecords(parsed.sessions)) {
+                    if (deletedIds.has(stored.id))
+                        continue;
                     sessions.upsert({
                         id: stored.id,
                         cwd: stored.cwd,
@@ -885,20 +1019,50 @@ export function createAcpFormalAgent(deps) {
     }
     async function loadSessionInternal(params) {
         await hydrateSessionsOnce();
+        validateAcpMcpServers(params.mcpServers);
         const session = sessions.get(params.sessionId);
         if (!session) {
             throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
         }
         if (session.cwd !== params.cwd) {
+            throw new RequestError(-32602, 'Invalid params: cwd does not match session cwd');
+        }
+        if (params.mcpServers) {
+            sessions.update(params.sessionId, (current) => ({
+                ...current,
+                mcpServers: params.mcpServers,
+            }));
+            await persistSessionsBestEffort();
+        }
+        return session;
+    }
+    async function resumeSessionInternal(params) {
+        await hydrateSessionsOnce();
+        validateAcpMcpServers(params.mcpServers);
+        const session = sessions.get(params.sessionId);
+        if (!session) {
+            throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
+        }
+        if (session.cwd !== params.cwd) {
+            throw new RequestError(-32602, 'Invalid params: cwd does not match session cwd');
+        }
+        if (params.mcpServers) {
             sessions.update(params.sessionId, (current) => ({
                 ...current,
-                cwd: params.cwd,
                 mcpServers: params.mcpServers ?? [],
             }));
             await persistSessionsBestEffort();
         }
         return session;
     }
+    function toSessionInfo(session) {
+        return {
+            sessionId: session.id,
+            cwd: session.cwd,
+            title: typeof session.title === 'string' && session.title.trim() ? session.title : null,
+            updatedAt: session.updatedAt,
+        };
+    }
     function ensureSessionRuntimeState(sessionId) {
         const existing = sessionRuntime.get(sessionId);
         if (existing)
@@ -932,7 +1096,11 @@ export function createAcpFormalAgent(deps) {
                     loadSession: loadSessionCapability,
                     promptCapabilities: promptCapabilities,
                     mcpCapabilities: mcpCapabilities,
-                    sessionCapabilities: {},
+                    sessionCapabilities: {
+                        list: {},
+                        resume: {},
+                        close: {},
+                    },
                 },
             };
         },
@@ -944,6 +1112,7 @@ export function createAcpFormalAgent(deps) {
             if (!isAbsolutePath(params.cwd)) {
                 throw new RequestError(-32602, 'Invalid params: cwd must be an absolute path');
             }
+            validateAcpMcpServers(params.mcpServers);
             const session = sessions.create({
                 cwd: params.cwd,
                 mcpServers: params.mcpServers ?? [],
@@ -1013,12 +1182,10 @@ export function createAcpFormalAgent(deps) {
             if (modeUpdate)
                 await emitSessionUpdate(session.id, modeUpdate);
             for (const entry of session.history) {
-                if (entry.role !== 'assistant')
-                    continue;
                 for (const block of entry.content) {
                     if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
                         await emitSessionUpdate(session.id, {
-                            sessionUpdate: 'agent_message_chunk',
+                            sessionUpdate: entry.role === 'assistant' ? 'agent_message_chunk' : 'user_message_chunk',
                             content: buildTextContentBlock(block.text),
                         });
                     }
@@ -1091,12 +1258,63 @@ export function createAcpFormalAgent(deps) {
             }
             return response;
         },
+        async listSessions(params) {
+            await hydrateSessionsOnce();
+            if (typeof params.cwd === 'string' && params.cwd && !isAbsolutePath(params.cwd)) {
+                throw new RequestError(-32602, 'Invalid params: cwd must be an absolute path');
+            }
+            const filtered = sessions
+                .list()
+                .filter((session) => !params.cwd || session.cwd === params.cwd)
+                .sort((a, b) => parseTimestamp(b.updatedAt) - parseTimestamp(a.updatedAt));
+            return {
+                sessions: filtered.map(toSessionInfo),
+            };
+        },
+        async resumeSession(params) {
+            const session = await resumeSessionInternal({
+                sessionId: params.sessionId,
+                cwd: params.cwd,
+                mcpServers: params.mcpServers,
+            });
+            const runtimeState = ensureSessionRuntimeState(session.id);
+            runtimeState.lastSessionInfoDigest = null;
+            await emitSessionInfoUpdateBestEffort(session.id);
+            const commandsUpdate = buildAvailableCommandsUpdateIfChanged(runtimeState);
+            if (commandsUpdate)
+                await emitSessionUpdate(session.id, commandsUpdate);
+            const modeUpdate = buildCurrentModeUpdateIfChanged(runtimeState);
+            if (modeUpdate)
+                await emitSessionUpdate(session.id, modeUpdate);
+            return {
+                configOptions: buildConfigOptions(runtimeState),
+                modes: buildModesState(runtimeState.modeId),
+            };
+        },
+        async closeSession(params) {
+            await hydrateSessionsOnce();
+            const session = sessions.get(params.sessionId);
+            if (!session)
+                return {};
+            sessions.update(params.sessionId, (current) => ({ ...current, cancelRequested: true }));
+            if (session.taskId) {
+                await deps.facade.cancelTask(session.taskId);
+            }
+            deletedSessionIds.set(params.sessionId, new Date().toISOString());
+            sessionRuntime.delete(params.sessionId);
+            sessions.delete(params.sessionId);
+            await persistSessionsBestEffort();
+            return {};
+        },
         async setSessionConfigOption(params) {
             await hydrateSessionsOnce();
             if (!sessions.get(params.sessionId)) {
                 throw new RequestError(-32004, `Session not found: ${params.sessionId}`);
             }
             const runtimeState = ensureSessionRuntimeState(params.sessionId);
+            if (typeof params.value !== 'string') {
+                throw new RequestError(-32602, `Invalid params: unsupported non-string value for "${params.configId}"`);
+            }
             if (params.configId === ACP_PERMISSION_POLICY_CONFIG_ID) {
                 if (!isPermissionPolicyValue(params.value)) {
                     throw new RequestError(-32602, `Invalid params: unsupported value "${params.value}" for "${params.configId}"`);
@@ -1245,6 +1463,7 @@ export function createAcpFormalAgent(deps) {
                 fileSystemOverride: effectiveExecutionBinding === 'client'
                     ? createAcpFileSystem({ conn: deps.conn, sessionId: params.sessionId })
                     : undefined,
+                extensions: acpMcpServersToExtensions(session.mcpServers),
                 authorizationProvider: createAcpToolAuthorizationProvider({
                     conn: deps.conn,
                     sessionId: params.sessionId,

package/dist/core/tools/mcp/client.js

@@ -2,6 +2,7 @@ import { createInterface } from 'readline';
 import { LIMITS } from '../../config/limits.js';
 import { getLogger } from '../../observability/logger.js';
 import { spawnInteractiveProcess } from '../../runtime/process-runner.js';
+import { PACKAGE_VERSION } from '../../version.js';
 import { assertOk, createMcpHeaders, decodeSseEvents, delayMs, isEventStreamResponse, safeDrainResponse, } from './streamable-http.js';
 /**
  * MCP Client handling JSON-RPC communication over stdio with an external server.
@@ -77,7 +78,7 @@ export class McpClient {
         await this.request('initialize', {
             protocolVersion: '2025-11-25',
             capabilities: {},
-            clientInfo: { name: 'salmon-loop', version: '0.2.0' },
+            clientInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
         });
         // Step 2: Signal initialized
         await this.notification('notifications/initialized', {});

package/dist/core/version.js

@@ -0,0 +1,17 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+function readPackageVersion() {
+    try {
+        const pkg = require('../../package.json');
+        if (typeof pkg.version === 'string' && pkg.version.trim()) {
+            return pkg.version;
+        }
+    }
+    catch {
+        // Fall back for non-package runtime embeddings.
+    }
+    return '0.0.0';
+}
+export const PACKAGE_NAME = 'salmon-loop';
+export const PACKAGE_VERSION = readPackageVersion();
+//# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salmon-loop",
-  "version": "0.2.16",
+  "version": "0.3.0",
   "description": "A chat-first coding agent CLI for safe, reviewable repository changes",
   "type": "module",
   "bin": {
@@ -126,7 +126,7 @@
   },
   "dependencies": {
     "@a2a-js/sdk": "0.3.10",
-    "@agentclientprotocol/sdk": "^0.14.1",
+    "@agentclientprotocol/sdk": "0.22.0",
     "@ai-sdk/openai": "^3.0.23",
     "@ai-sdk/openai-compatible": "^2.0.24",
     "@inquirer/prompts": "^8.2.0",