@geminilight/mindos 1.1.50 → 1.1.52

package/dist/protocols/acp/session.js

@@ -6,6 +6,9 @@
 import { spawnAndConnect, killAgent, } from './subprocess.js';
 import { findAcpAgent } from './registry.js';
 import { resolveConfiguredAcpAgentEntry } from './agent-descriptors.js';
+import { buildAcpSessionMcpInheritancePlan, } from './mcp-session-inheritance.js';
+import { recordArtifactsFromAcpToolCall } from '../../agent/ledger/artifact-ledger.js';
+import { redactSensitiveText } from '../../agent/redaction.js';
 function withTimeout(promise, timeoutMs, message) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
@@ -53,6 +56,32 @@ function clientCapabilitiesForPermissionMode(mode) {
         terminal: !readonly,
     };
 }
+function resolveSessionMcpInheritance(options, agentCapabilities) {
+    if (options?.mcpServers) {
+        return {
+            servers: options.mcpServers,
+            summaries: options.mcpServers.map((server) => ({
+                name: server.name,
+                type: 'type' in server && server.type === 'http'
+                    ? 'http'
+                    : 'type' in server && server.type === 'sse'
+                        ? 'sse'
+                        : 'stdio',
+            })),
+        };
+    }
+    if (options?.inheritMcpServers === false || !options?.mcpConfig) {
+        return { servers: [], summaries: [] };
+    }
+    const plan = buildAcpSessionMcpInheritancePlan({
+        config: options.mcpConfig,
+        agentCapabilities,
+    });
+    return {
+        servers: plan.servers,
+        summaries: plan.summaries,
+    };
+}
 /* ── State ─────────────────────────────────────────────────────────────── */
 const sessions = new Map();
 const sessionConnections = new Map();
@@ -109,17 +138,21 @@ export async function createSessionFromEntry(entry, options) {
     // Phase 3: session/new
     let modes;
     let configOptions;
+    let currentModeId;
     let agentSessionId;
+    const mcpInheritance = resolveSessionMcpInheritance(options, agentCapabilities);
     try {
         const newResult = await conn.connection.newSession({
             cwd: sessionCwd,
-            mcpServers: [],
+            mcpServers: mcpInheritance.servers,
         });
         if (typeof newResult.sessionId === 'string') {
             agentSessionId = newResult.sessionId;
         }
         modes = parseModes(newResult.modes);
+        currentModeId = parseCurrentModeId(newResult.modes);
         configOptions = parseConfigOptions(newResult.configOptions);
+        currentModeId ??= currentModeFromConfig(configOptions);
     }
     catch (sessionErr) {
         const msg = sessionErr.message ?? '';
@@ -139,7 +172,9 @@ export async function createSessionFromEntry(entry, options) {
         agentCapabilities,
         modes,
         configOptions,
+        currentModeId,
         authMethods,
+        mcpServers: mcpInheritance.summaries,
     };
     sessions.set(sessionId, session);
     sessionConnections.set(sessionId, conn);
@@ -177,14 +212,18 @@ export async function loadSession(agentId, existingSessionId, options) {
     }
     let modes;
     let configOptions;
+    let currentModeId;
+    const mcpInheritance = resolveSessionMcpInheritance(options, agentCapabilities);
     try {
         const loadResult = await conn.connection.loadSession({
             sessionId: existingSessionId,
             cwd: loadCwd,
-            mcpServers: [],
+            mcpServers: mcpInheritance.servers,
         });
         modes = parseModes(loadResult.modes);
+        currentModeId = parseCurrentModeId(loadResult.modes);
         configOptions = parseConfigOptions(loadResult.configOptions);
+        currentModeId ??= currentModeFromConfig(configOptions);
     }
     catch (err) {
         killAgent(conn.process);
@@ -201,6 +240,8 @@ export async function loadSession(agentId, existingSessionId, options) {
         agentCapabilities,
         modes,
         configOptions,
+        currentModeId,
+        mcpServers: mcpInheritance.summaries,
     };
     sessions.set(existingSessionId, session);
     sessionConnections.set(existingSessionId, conn);
@@ -230,6 +271,9 @@ export async function listSessions(sessionId, options) {
 }
 /* ── Public API — Prompt ──────────────────────────────────────────────── */
 const PROMPT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const TOOL_RAW_TEXT_LIMIT = 4000;
+const INLINE_IMAGE_RESULT_LIMIT = 64 * 1024;
+const INLINE_IMAGE_PREFIX_RE = /^(?:data:image\/|iVBORw0KGgo|\/9j\/|UklGR)/;
 /**
  * Send a prompt and collect the full response.
  * Text arrives via session/update notifications (handled by SDK → Client.sessionUpdate).
@@ -244,10 +288,17 @@ export async function prompt(sessionId, text) {
     let notificationText = '';
     conn.callbacks.onSessionUpdate = (params) => {
         const update = sdkNotificationToUpdate(sessionId, params);
+        applySessionUpdate(session, update);
         if ((update.type === 'agent_message_chunk' || update.type === 'text') && update.text) {
             notificationText += update.text;
         }
     };
+    conn.callbacks.onPermissionRequest = (event) => {
+        applySessionUpdate(session, { sessionId, type: 'permission_request', permission: event });
+    };
+    conn.callbacks.onPermissionResolved = (event) => {
+        applySessionUpdate(session, { sessionId, type: 'permission_resolved', permission: event });
+    };
     try {
         const result = await withTimeout(conn.connection.prompt({
             sessionId: wireSessionId,
@@ -267,6 +318,8 @@ export async function prompt(sessionId, text) {
     }
     finally {
         conn.callbacks.onSessionUpdate = undefined;
+        conn.callbacks.onPermissionRequest = undefined;
+        conn.callbacks.onPermissionResolved = undefined;
     }
 }
 /**
@@ -282,13 +335,21 @@ export async function promptStream(sessionId, text, onUpdate) {
     let aggregatedText = '';
     conn.callbacks.onSessionUpdate = (params) => {
         const update = sdkNotificationToUpdate(sessionId, params);
+        applySessionUpdate(session, update);
         onUpdate(update);
         if ((update.type === 'agent_message_chunk' || update.type === 'text') && update.text) {
             aggregatedText += update.text;
         }
-        if (update.type === 'config_option_update' && update.configOptions) {
-            session.configOptions = update.configOptions;
-        }
+    };
+    conn.callbacks.onPermissionRequest = (event) => {
+        const update = { sessionId, type: 'permission_request', permission: event };
+        applySessionUpdate(session, update);
+        onUpdate(update);
+    };
+    conn.callbacks.onPermissionResolved = (event) => {
+        const update = { sessionId, type: 'permission_resolved', permission: event };
+        applySessionUpdate(session, update);
+        onUpdate(update);
     };
     try {
         const result = await withTimeout(conn.connection.prompt({
@@ -310,6 +371,8 @@ export async function promptStream(sessionId, text, onUpdate) {
     }
     finally {
         conn.callbacks.onSessionUpdate = undefined;
+        conn.callbacks.onPermissionRequest = undefined;
+        conn.callbacks.onPermissionResolved = undefined;
     }
 }
 /* ── Public API — Session Control ─────────────────────────────────────── */
@@ -330,6 +393,7 @@ export async function setMode(sessionId, modeId) {
     const { session, conn } = getSessionAndConn(sessionId);
     const wireSessionId = session.agentSessionId ?? sessionId;
     await conn.connection.setSessionMode({ sessionId: wireSessionId, modeId });
+    session.currentModeId = modeId;
     session.lastActivityAt = new Date().toISOString();
 }
 export async function setConfigOption(sessionId, configId, value) {
@@ -341,8 +405,10 @@ export async function setConfigOption(sessionId, configId, value) {
         value,
     });
     const configOptions = parseConfigOptions(result.configOptions);
-    if (configOptions)
+    if (configOptions) {
         session.configOptions = configOptions;
+        session.currentModeId = currentModeFromConfig(configOptions) ?? session.currentModeId;
+    }
     session.lastActivityAt = new Date().toISOString();
     return session.configOptions ?? [];
 }
@@ -370,6 +436,14 @@ export function getActiveSessions() {
     reapStaleSessions();
     return [...sessions.values()];
 }
+export function getSessionSnapshot(sessionId) {
+    const session = sessions.get(sessionId);
+    return session ? buildAcpSessionSnapshot(session) : undefined;
+}
+export function getActiveSessionSnapshots() {
+    reapStaleSessions();
+    return [...sessions.values()].map(buildAcpSessionSnapshot);
+}
 export async function closeAllSessions() {
     const ids = [...sessions.keys()];
     await Promise.allSettled(ids.map(id => closeSession(id)));
@@ -390,6 +464,76 @@ function updateSessionState(session, state) {
     session.state = state;
     session.lastActivityAt = new Date().toISOString();
 }
+export function buildAcpSessionSnapshot(session) {
+    const modes = session.modes ?? [];
+    const configOptions = session.configOptions ?? [];
+    const toolCalls = session.toolCalls ?? [];
+    const permissionEvents = session.permissionEvents ?? [];
+    return {
+        schemaVersion: 1,
+        sessionId: session.id,
+        agentId: session.agentId,
+        ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+        state: session.state,
+        ...(session.cwd ? { cwd: session.cwd } : {}),
+        createdAt: session.createdAt,
+        lastActivityAt: session.lastActivityAt,
+        ...(session.agentCapabilities ? { agentCapabilities: session.agentCapabilities } : {}),
+        authMethods: session.authMethods ?? [],
+        modes,
+        ...(session.currentModeId ? { currentModeId: session.currentModeId } : {}),
+        configOptions,
+        controls: {
+            model: buildControlSnapshot(configOptions, 'model'),
+            mode: buildModeControlSnapshot(configOptions, modes, session.currentModeId),
+            thoughtLevel: buildControlSnapshot(configOptions, 'thought_level'),
+        },
+        availableCommands: session.availableCommands ?? [],
+        toolCalls,
+        toolSummary: summarizeToolCalls(toolCalls),
+        permissionEvents,
+        pendingPermissions: permissionEvents.filter((event) => event.status === 'pending'),
+        ...(session.sessionInfo ? { sessionInfo: session.sessionInfo } : {}),
+        mcpServers: session.mcpServers ?? [],
+    };
+}
+function applySessionUpdate(session, update) {
+    session.lastActivityAt = new Date().toISOString();
+    if (update.type === 'available_commands_update') {
+        session.availableCommands = parseAvailableCommands(update.availableCommands);
+        return;
+    }
+    if (update.type === 'current_mode_update' && update.currentModeId) {
+        session.currentModeId = update.currentModeId;
+        return;
+    }
+    if (update.type === 'config_option_update' && update.configOptions) {
+        session.configOptions = update.configOptions;
+        session.currentModeId = currentModeFromConfig(update.configOptions) ?? session.currentModeId;
+        return;
+    }
+    if ((update.type === 'tool_call' || update.type === 'tool_call_update') && update.toolCall) {
+        session.toolCalls = upsertToolCall(session.toolCalls, update.toolCall);
+        recordArtifactsFromAcpToolCall({
+            runtimeId: session.agentId,
+            sessionId: session.id,
+            ...(session.agentSessionId ? { externalSessionId: session.agentSessionId } : {}),
+            ...(session.cwd ? { cwd: session.cwd } : {}),
+            toolCall: update.toolCall,
+        });
+        return;
+    }
+    if (update.type === 'session_info_update' && update.sessionInfo) {
+        session.sessionInfo = {
+            ...session.sessionInfo,
+            ...update.sessionInfo,
+        };
+        return;
+    }
+    if ((update.type === 'permission_request' || update.type === 'permission_resolved') && update.permission) {
+        session.permissionEvents = upsertPermissionEvent(session.permissionEvents, update.permission);
+    }
+}
 /* ── Internal — SDK notification → MindOS update ──────────────────────── */
 /**
  * Convert SDK SessionNotification to MindOS AcpSessionUpdate.
@@ -416,13 +560,20 @@ function sdkNotificationToUpdate(sessionId, params) {
         case 'tool_call':
         case 'tool_call_update': {
             const tc = update;
+            const rawOutputPointers = extractRawOutputPointers(tc.rawOutput ?? tc.raw_output);
+            const locations = [
+                ...parseToolCallLocations(tc.locations),
+                ...rawOutputPointers.locations,
+            ];
             base.toolCall = {
                 toolCallId: String(tc.toolCallId ?? ''),
                 title: typeof tc.title === 'string' ? tc.title : undefined,
                 status: tc.status ?? 'pending',
                 kind: tc.kind,
-                rawInput: typeof tc.rawInput === 'string' ? tc.rawInput : undefined,
-                rawOutput: typeof tc.rawOutput === 'string' ? tc.rawOutput : undefined,
+                rawInput: safeToolRawText(tc.rawInput),
+                rawOutput: safeToolRawText(tc.rawOutput ?? tc.raw_output),
+                content: parseToolCallContent(tc.content),
+                ...(locations.length > 0 ? { locations } : {}),
             };
             break;
         }
@@ -457,6 +608,110 @@ function sdkNotificationToUpdate(sessionId, params) {
     }
     return base;
 }
+function safeToolRawText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length > INLINE_IMAGE_RESULT_LIMIT
+        && INLINE_IMAGE_PREFIX_RE.test(trimmed)) {
+        return undefined;
+    }
+    const redacted = redactSensitiveText(trimmed);
+    return redacted.length > TOOL_RAW_TEXT_LIMIT
+        ? `${redacted.slice(0, TOOL_RAW_TEXT_LIMIT)}...`
+        : redacted;
+}
+function parseToolCallLocations(value) {
+    if (!Array.isArray(value))
+        return [];
+    const locations = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const record = item;
+        const rawPath = typeof record.path === 'string'
+            ? record.path
+            : typeof record.uri === 'string' && record.uri.startsWith('file://')
+                ? record.uri.slice('file://'.length)
+                : '';
+        const path = rawPath.trim();
+        if (!path)
+            continue;
+        const line = typeof record.line === 'number' && Number.isFinite(record.line)
+            ? Math.max(1, Math.floor(record.line))
+            : undefined;
+        const key = `${path}:${line ?? ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        locations.push({ path, ...(line ? { line } : {}) });
+        if (locations.length >= 50)
+            break;
+    }
+    return locations;
+}
+function parseToolCallContent(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const blocks = [];
+    for (const item of value) {
+        const block = parseToolCallContentBlock(item);
+        if (block)
+            blocks.push(block);
+        if (blocks.length >= 50)
+            break;
+    }
+    return blocks.length > 0 ? blocks : undefined;
+}
+function parseToolCallContentBlock(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.type === 'resource_link' && typeof record.uri === 'string') {
+        return {
+            type: 'resource_link',
+            uri: record.uri,
+            name: typeof record.name === 'string' && record.name.trim() ? record.name : 'resource',
+        };
+    }
+    if (record.type === 'resource') {
+        const resource = record.resource;
+        if (!resource || typeof resource !== 'object' || Array.isArray(resource))
+            return null;
+        const resourceRecord = resource;
+        if (typeof resourceRecord.uri !== 'string')
+            return null;
+        return {
+            type: 'resource',
+            resource: {
+                uri: resourceRecord.uri,
+                ...(typeof resourceRecord.text === 'string' ? { text: safeToolRawText(resourceRecord.text) ?? '' } : {}),
+            },
+        };
+    }
+    return null;
+}
+function extractRawOutputPointers(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return { locations: [] };
+    const record = value;
+    const candidates = [
+        record.saved_path,
+        record.savedPath,
+        readNestedString(record.image, 'path'),
+        readNestedString(record.artifact, 'path'),
+    ];
+    const locations = candidates
+        .filter((candidate) => typeof candidate === 'string' && candidate.trim().length > 0)
+        .map((candidate) => ({ path: candidate.trim() }));
+    return { locations };
+}
+function readNestedString(value, key) {
+    return value && typeof value === 'object' && !Array.isArray(value) && typeof value[key] === 'string'
+        ? value[key]
+        : undefined;
+}
 /* ── Internal — Parsers ───────────────────────────────────────────────── */
 function parseAgentCapabilities(raw) {
     if (!raw || typeof raw !== 'object')
@@ -499,6 +754,20 @@ function parseModes(raw) {
     }))
         .filter(m => m.id && m.name);
 }
+function parseCurrentModeId(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const obj = raw;
+    if (typeof obj.currentModeId === 'string' && obj.currentModeId.trim())
+        return obj.currentModeId.trim();
+    const currentMode = obj.currentMode;
+    if (currentMode && typeof currentMode === 'object' && !Array.isArray(currentMode)) {
+        const id = currentMode.id;
+        if (typeof id === 'string' && id.trim())
+            return id.trim();
+    }
+    return undefined;
+}
 function parseConfigOptions(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return undefined;
@@ -508,15 +777,174 @@ function parseConfigOptions(raw) {
         type: 'select',
         configId: String(o.configId ?? o.id ?? ''),
         category: String(o.category ?? 'other'),
-        label: typeof o.label === 'string' ? o.label : undefined,
+        label: typeof o.label === 'string' ? o.label : typeof o.name === 'string' ? o.name : undefined,
         currentValue: String(o.currentValue ?? ''),
-        options: Array.isArray(o.options) ? o.options.map((opt) => {
-            const optObj = opt;
-            return { id: String(optObj.id ?? ''), label: String(optObj.label ?? '') };
-        }) : [],
+        options: parseConfigOptionEntries(o.options),
     }))
         .filter(o => o.configId);
 }
+function parseConfigOptionEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const entries = [];
+    const pushEntry = (option) => {
+        if (!option || typeof option !== 'object' || Array.isArray(option))
+            return;
+        const record = option;
+        const id = String(record.id ?? record.value ?? '').trim();
+        const label = String(record.label ?? record.name ?? id).trim();
+        if (id)
+            entries.push({ id, label: label || id });
+    };
+    for (const item of raw) {
+        if (item && typeof item === 'object' && !Array.isArray(item) && Array.isArray(item.options)) {
+            for (const nested of item.options) {
+                pushEntry(nested);
+            }
+            continue;
+        }
+        pushEntry(item);
+    }
+    return entries;
+}
+function parseAvailableCommands(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const seen = new Set();
+    const commands = [];
+    for (const entry of raw) {
+        const command = normalizeAvailableCommand(entry);
+        if (!command || seen.has(command.id))
+            continue;
+        seen.add(command.id);
+        commands.push(command);
+        if (commands.length >= 100)
+            break;
+    }
+    return commands;
+}
+function normalizeAvailableCommand(entry) {
+    if (typeof entry === 'string') {
+        const name = entry.trim().replace(/^\//, '');
+        return name ? { id: name, name } : null;
+    }
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+        return null;
+    const record = entry;
+    const rawName = record.name ?? record.id ?? record.command ?? record.title;
+    if (typeof rawName !== 'string')
+        return null;
+    const name = rawName.trim().replace(/^\//, '');
+    if (!name)
+        return null;
+    const id = typeof record.id === 'string' && record.id.trim()
+        ? record.id.trim().replace(/^\//, '')
+        : name;
+    const description = typeof record.description === 'string' && record.description.trim()
+        ? record.description.trim().slice(0, 300)
+        : undefined;
+    return {
+        id,
+        name,
+        ...(description ? { description } : {}),
+    };
+}
+function currentModeFromConfig(configOptions) {
+    const option = findConfigOption(configOptions ?? [], 'mode');
+    return option?.currentValue?.trim() || undefined;
+}
+function buildControlSnapshot(configOptions, category) {
+    const option = findConfigOption(configOptions, category);
+    if (!option) {
+        return {
+            status: 'unavailable',
+            source: 'unavailable',
+            options: [],
+        };
+    }
+    return {
+        status: 'available',
+        source: 'observed',
+        configId: option.configId,
+        currentValue: option.currentValue,
+        options: option.options,
+    };
+}
+function buildModeControlSnapshot(configOptions, modes, currentModeId) {
+    const option = findConfigOption(configOptions, 'mode');
+    if (option) {
+        return {
+            status: 'available',
+            source: 'observed',
+            configId: option.configId,
+            ...(currentModeId ?? option.currentValue ? { currentValue: currentModeId ?? option.currentValue } : {}),
+            options: option.options,
+        };
+    }
+    if (modes.length === 0) {
+        return {
+            status: 'unavailable',
+            source: 'unavailable',
+            options: [],
+        };
+    }
+    return {
+        status: 'available',
+        source: currentModeId ? 'observed' : 'declared',
+        ...(currentModeId ? { currentValue: currentModeId } : {}),
+        options: modes.map((mode) => ({ id: mode.id, label: mode.name })),
+    };
+}
+function findConfigOption(configOptions, category) {
+    return configOptions.find((option) => {
+        const optionCategory = option.category.toLowerCase();
+        const configId = option.configId.toLowerCase();
+        if (category === 'thought_level') {
+            return optionCategory === 'thought_level'
+                || optionCategory === 'reasoning'
+                || configId === 'thought_level'
+                || configId === 'thinking'
+                || configId === 'reasoning_effort';
+        }
+        return optionCategory === category || configId === category;
+    });
+}
+function upsertToolCall(existing, update) {
+    if (!update.toolCallId)
+        return existing ?? [];
+    const next = [...(existing ?? [])];
+    const index = next.findIndex((toolCall) => toolCall.toolCallId === update.toolCallId);
+    if (index === -1)
+        return [...next, update].slice(-100);
+    next[index] = {
+        ...next[index],
+        ...update,
+        status: update.status ?? next[index].status,
+    };
+    return next;
+}
+function summarizeToolCalls(toolCalls) {
+    return {
+        total: toolCalls.length,
+        pending: toolCalls.filter((toolCall) => toolCall.status === 'pending').length,
+        inProgress: toolCalls.filter((toolCall) => toolCall.status === 'in_progress').length,
+        completed: toolCalls.filter((toolCall) => toolCall.status === 'completed').length,
+        failed: toolCalls.filter((toolCall) => toolCall.status === 'failed').length,
+    };
+}
+function upsertPermissionEvent(existing, update) {
+    const next = [...(existing ?? [])];
+    const index = next.findIndex((event) => event.requestId === update.requestId);
+    if (index === -1)
+        return [...next, update].slice(-100);
+    next[index] = {
+        ...next[index],
+        ...update,
+        options: update.options.length > 0 ? update.options : next[index].options,
+        requestedAt: next[index].requestedAt || update.requestedAt,
+    };
+    return next;
+}
 /* ── Internal — Session limits ─────────────────────────────────────────── */
 function checkSessionLimits(agentId) {
     if (sessions.size >= MAX_TOTAL_SESSIONS) {