newmark-agent 0.3.12 → 0.4.0

package/dist/main.js

@@ -73,6 +73,7 @@ const startupPrewarm_1 = require("./core/startupPrewarm");
 const runtimeShutdown_1 = require("./core/runtimeShutdown");
 const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
 const compat_1 = require("./core/compat");
+const dshCompatibility_1 = require("./core/dshCompatibility");
 const mcpManager_1 = require("./core/mcpManager");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
@@ -123,6 +124,7 @@ let browserUseEngine = null;
 // the authoritative Browser-Use/right-sidebar binding.
 const browserGuestContentsByHost = new Map();
 const browserGuestBindingsByRuntime = new Map();
+const browserGuestKeyboardBridgeIds = new Set();
 function browserGuestRuntimeKey(target) {
     return (0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey;
 }
@@ -686,9 +688,13 @@ function resolveTuiWorkspacePath(args, root) {
     // while making the safe one-argument form fully self-contained.
     return pathArgValue(args, '--root') ? root : process.cwd();
 }
+// Set immediately after argument resolution so startup failures from an
+// explicit temporary root are recorded beside that root instead of leaking a
+// diagnostic file into the user's canonical runtime.
+let startupRuntimeRoot = '';
 function startupLogPath() {
     try {
-        const userData = userRuntimeRoot();
+        const userData = startupRuntimeRoot || userRuntimeRoot();
         fs.mkdirSync(userData, { recursive: true });
         return path.join(userData, 'startup.log');
     }
@@ -841,7 +847,29 @@ function registerBrowserGuest(host, guest, requestedTarget) {
         conversationId: target.conversationId,
     });
     browserGuestContentsByHost.set(host.id, guest.id);
+    if (!browserGuestKeyboardBridgeIds.has(guest.id)) {
+        browserGuestKeyboardBridgeIds.add(guest.id);
+        // WebView keyboard events do not bubble to the host renderer. Reserve only
+        // the two app-wide discovery surfaces and leave navigation/editing keys to
+        // the page itself.
+        guest.on('before-input-event', (event, input) => {
+            if (input.type !== 'keyDown' || input.isAutoRepeat || host.isDestroyed())
+                return;
+            const key = String(input.key || '').toLowerCase();
+            const noSecondaryModifiers = !input.alt && !input.control && !input.meta && !input.shift;
+            let commandId = '';
+            if (key === 'f1' && noSecondaryModifiers)
+                commandId = 'help.keyboardShortcuts';
+            else if (key === 'p' && (input.control || input.meta) && input.shift && !input.alt)
+                commandId = 'app.commandPalette';
+            if (!commandId)
+                return;
+            event.preventDefault();
+            host.send('keyboard:command', { id: commandId, source: 'browserGuest' });
+        });
+    }
     guest.once('destroyed', () => {
+        browserGuestKeyboardBridgeIds.delete(guest.id);
         if (browserGuestContentsByHost.get(host.id) === guest.id)
             browserGuestContentsByHost.delete(host.id);
         const binding = browserGuestBindingsByRuntime.get(target.runtimeKey);
@@ -1035,6 +1063,7 @@ const args = userArgs();
 const command = args.find(a => a === 'flow' || a === 'edit');
 const isTuiArg = args.some(arg => arg.toLowerCase() === '--tui');
 const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const cliCommand = args.find(a => cli_commands_1.CLI_COMMANDS.includes(a));
 const isFlowArg = command === 'flow';
 const isEditArg = command === 'edit';
 const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
@@ -1048,18 +1077,34 @@ if (invalidArgument) {
     console.error(`Invalid Newmark argument: ${invalidArgument}`);
     process.exit(2);
 }
+// Keep command-specific help on the same early-exit path as top-level help.
+// This matters for the packaged Electron entry: a command such as
+// `send --help` must never create a GUI window, start prewarm work, or touch a
+// user-data profile merely to print its contract.
+if (hasCliCommand && cliCommand && (0, cli_commands_1.cliHelpRequested)(args)) {
+    console.log((0, cli_commands_1.cliCommandHelp)(cliCommand));
+    process.exit(0);
+}
 // Electron's Chromium profile is a separate state boundary from Newmark's
 // business root. Bind both before any ready event so --root cannot leave
 // Preferences, DIPS, DevTools ports, cookies, or session storage in the real
 // default AppData directory. The dedicated subdirectories keep Chromium's
 // files separate from the durable Newmark config/workspace files.
 const runtimeRoot = resolveRoot(args);
-const electronUserDataRoot = path.join(runtimeRoot, 'Electron');
+startupRuntimeRoot = runtimeRoot;
+const explicitElectronUserDataRoot = pathArgValue(args, '--user-data-dir');
+const electronUserDataRoot = path.resolve(explicitElectronUserDataRoot || path.join(runtimeRoot, 'Electron'));
 const electronSessionDataRoot = path.join(electronUserDataRoot, 'session-data');
 try {
     fs.mkdirSync(electronSessionDataRoot, { recursive: true });
     electron_1.app.setPath('userData', electronUserDataRoot);
     electron_1.app.setPath('sessionData', electronSessionDataRoot);
+    // app.setPath is the Electron API contract; the switch makes the same
+    // boundary visible to Chromium children, including the console-wrapper
+    // `--` forwarding path where an early child may otherwise retain the default
+    // profile before the first BrowserWindow is created.
+    electron_1.app.commandLine.removeSwitch('user-data-dir');
+    electron_1.app.commandLine.appendSwitch('user-data-dir', electronUserDataRoot);
 }
 catch (error) {
     console.error(`Unable to isolate Electron user-data directory: ${error instanceof Error ? error.message : String(error)}`);
@@ -1659,6 +1704,12 @@ else {
                         win.focus();
                     }, 150);
                 });
+                win.webContents.on('unresponsive', () => {
+                    logStartupFailure('renderer-unresponsive', new Error(`Window renderer became unresponsive (webContents ${win.webContents.id})`));
+                });
+                win.webContents.on('responsive', () => {
+                    recordStartup(`renderer-responsive-${win.webContents.id}`);
+                });
                 if (!automationWakeMode)
                     win.maximize();
                 if (!automationWakeMode && showWindow) {
@@ -1674,15 +1725,18 @@ else {
                         return;
                     if (agent) {
                         const closeBehavior = agent.config.getStr('general', 'close_behavior');
+                        recordStartup(`window-close-requested-${closeBehavior || 'exit'}`);
                         if (closeBehavior === 'minimize') {
                             e.preventDefault();
                             win.hide();
                             createTray();
+                            recordStartup('window-hidden-to-tray');
                             return;
                         }
                         if (agent.config.getBool('general', 'auto_archive_on_close')) {
                             agent.archiveSession();
                         }
+                        recordStartup('window-close-exit');
                     }
                 });
                 win.on('closed', () => {
@@ -2299,6 +2353,7 @@ else {
                     (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
             };
             electron_1.app.on('will-quit', event => {
+                recordStartup('will-quit');
                 // Window-close and tray-exit both enter this path. The runtime pools
                 // must get a bounded graceful-shutdown window regardless of which
                 // surface initiated the close; otherwise a stuck child can keep the
@@ -2462,6 +2517,32 @@ else {
                 activeFlowsByRuntimeKey.delete(key);
                 agent.clearStoredFlowSuspension(state.target.conversationId);
             };
+            // Archive is a destructive lifecycle boundary. It must cancel the Flow
+            // owner itself before touching the runtime pool; Flow runs bypass the
+            // ConversationKernel and therefore cannot be stopped by the pool alone.
+            // Marking the state before aborting is important: the provider may reject
+            // on the same turn, and its late catch/finally must not recreate a paused
+            // conversation after archive has removed it.
+            const interruptActiveFlowForArchive = (target) => {
+                const key = activeFlowStateKey(target);
+                const state = activeFlowsByRuntimeKey.get(key) || null;
+                if (!state)
+                    return;
+                state.archiveRequested = true;
+                try {
+                    state.abortController?.abort(new Error(`Flow discarded because conversation was archived: ${state.name || state.workflow.name}`));
+                }
+                catch { }
+                state.flowAgent?.abortActiveKernelRun();
+                state.flowAgent?.interruptRunningConversationWorkRuns(state.target, 'force_interrupted');
+                state.flowAgent?.clearStoredFlowSuspension(state.target.conversationId);
+                if (agent?.workspace.current
+                    && target.workspace
+                    && path.resolve(agent.workspace.current.path) === path.resolve(target.workspace.path)) {
+                    agent.clearStoredFlowSuspension(target.conversationId);
+                }
+                activeFlowsByRuntimeKey.delete(key);
+            };
             const utilityHostToolHandler = (0, utilityHostToolRouter_1.createUtilityHostToolHandler)({
                 persistenceRoot: root,
                 isToolEnabled: toolName => !!agent && (0, nativeTools_1.isNativeToolEnabled)(toolName, agent.config.nativeToolEnabled()),
@@ -2851,6 +2932,14 @@ else {
                     };
                 }
                 catch (e) {
+                    if (flowState.archiveRequested) {
+                        // Archive already force-finalized the current Build ledger. Do not
+                        // persist an interrupted Flow suspension or return Flow ownership
+                        // to the renderer after the target has been removed.
+                        flowAgent.pendingOptions = [];
+                        suspended = false;
+                        return { ok: false, archived: true, error: 'Flow discarded because the conversation was archived.' };
+                    }
                     if (e instanceof flow_runner_1.FlowQuestionPendingError) {
                         suspended = true;
                         flowAgent.flowPc = e.componentId;
@@ -2944,6 +3033,11 @@ else {
                 const flowKey = activeFlowStateKey(flowTarget);
                 const flowAgent = isolatedConversationAgent(flowTarget);
                 suspension.flowAgent = flowAgent;
+                // A previous Flow may have been interrupted just before its isolated
+                // Agent flushed the work ledger. Reconcile only this explicitly paused
+                // target before starting the next component; the normal runner guard
+                // remains intact for genuine concurrent Builds.
+                flowAgent.interruptRunningConversationWorkRuns(flowTarget, 'interrupted');
                 const flowAbortController = new AbortController();
                 suspension.abortController = flowAbortController;
                 activeFlowsByRuntimeKey.set(flowKey, suspension);
@@ -2978,6 +3072,11 @@ else {
                     };
                 }
                 catch (error) {
+                    if (suspension.archiveRequested) {
+                        flowAgent.pendingOptions = [];
+                        suspendedAgain = false;
+                        return { ok: false, archived: true, error: 'Flow discarded because the conversation was archived.' };
+                    }
                     if (error instanceof flow_runner_1.FlowQuestionPendingError) {
                         suspendedAgain = true;
                         flowAgent.flowPc = error.componentId;
@@ -2999,9 +3098,9 @@ else {
                             workRuns: flowAgent.getConversationSnapshot(flowAgent.activeConversationId).workRuns,
                         };
                     }
-                    if (isUserFlowAbort(error)) {
-                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-                    }
+                    // A Stop/Esc during a resumed Flow is another pause, not a terminal
+                    // IPC failure. Fall through to the same interrupted-suspension path as
+                    // the initial Flow run so repeated pause/resume clicks remain valid.
                     suspendedAgain = true;
                     const resumeFailure = error;
                     const interruptedComponentId = typeof resumeFailure.componentId === 'number'
@@ -3154,6 +3253,12 @@ else {
                     runtimeDeferred: false,
                 };
             });
+            electron_1.ipcMain.handle('agent:setConversationBranchCommunication', async (_event, targetInput, enabled) => {
+                if (!agent)
+                    return false;
+                const target = conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default');
+                return mutateTargetConversation(target, () => isolatedConversationAgent(target).setBranchCommunication(enabled !== false));
+            });
             electron_1.ipcMain.handle('agent:computerUseState', async (_event, targetInput) => {
                 if (!agent)
                     return { enabled: false, occupied: false, runtimeKey: '' };
@@ -3691,6 +3796,18 @@ else {
                     ? await ensureWslConversationPool().checkpoint(target)
                     : await ensureElectronUtilityPool().checkpoint(target);
             });
+            electron_1.ipcMain.handle('agent:compressContext', async (_event, request) => {
+                if (!agent)
+                    throw new Error('Agent not initialized');
+                const target = conversationRuntimeTarget(request);
+                const options = {
+                    keepRecent: Number.isFinite(Number(request?.keepRecent)) ? Math.floor(Number(request.keepRecent)) : undefined,
+                    force: request?.force !== false,
+                };
+                return wslBackendEnabled()
+                    ? await ensureWslConversationPool().contextCompress(target, options)
+                    : await ensureElectronUtilityPool().contextCompress(target, options);
+            });
             electron_1.ipcMain.handle('agent:rateAutoRoute', async (_event, request) => {
                 if (!agent)
                     return { ok: false, reason: 'no_active_auto_route' };
@@ -3847,9 +3964,14 @@ else {
                     mutatingRuntimeKeys.add(normalized.runtimeKey);
                     try {
                         // Archive is a destructive lifecycle command. It intentionally
-                        // bypasses the normal mutation/active-prompt guard and hard-stops
-                        // any resident runtime before touching conversation persistence.
-                        await forceStopTargetRuntime(normalized);
+                        // bypasses the normal mutation/active-prompt guard. Cancel the
+                        // conversation-local Flow synchronously, then start the resident
+                        // runtime hard-stop in the background so a stuck child cannot hold
+                        // the archive click hostage.
+                        interruptActiveFlowForArchive(normalized);
+                        void forceStopTargetRuntime(normalized).catch(error => {
+                            console.error('[Newmark] archive runtime force-stop failed:', error instanceof Error ? error.message : String(error));
+                        });
                         const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
                         const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
                         const ownsTargetWorkspace = !!normalized.workspace
@@ -3861,6 +3983,7 @@ else {
                         // latest locked state snapshot, so rapid clicks do not serialize on
                         // large Markdown bodies or lose a sibling deletion.
                         const archiveOwner = ownsTargetWorkspace ? agent : isolatedConversationAgent(normalized);
+                        archiveOwner.clearStoredFlowSuspension(normalized.conversationId);
                         const archived = await archiveOwner.archiveConversationAsync(normalized.conversationId);
                         if (!archived)
                             return { ok: false, error: 'Conversation archive could not be written.' };
@@ -4205,6 +4328,20 @@ else {
                 }
                 return { error: 'Agent not initialized' };
             });
+            electron_1.ipcMain.handle('app:openWebUrl', async (_event, rawUrl) => {
+                try {
+                    const target = new URL(String(rawUrl || ''));
+                    const allowedHosts = new Set(['github.com', 'www.github.com', 'npmjs.com', 'www.npmjs.com']);
+                    if (target.protocol !== 'https:' || !allowedHosts.has(target.hostname.toLowerCase()) || !!target.username || !!target.password || (!!target.port && target.port !== '443')) {
+                        return { ok: false, error: 'Only approved HTTPS documentation hosts can be opened.' };
+                    }
+                    await electron_1.shell.openExternal(target.toString());
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            });
             electron_1.ipcMain.handle('agent:selectWorkspace', async (_event, id) => {
                 if (agent) {
                     const requested = String(id || '').trim();
@@ -4502,13 +4639,25 @@ else {
                 const controller = new AbortController();
                 editorCompletionControllers.set(ownerId, controller);
                 try {
-                    return await (agent?.editorModelRequest({ ...request, completion: true, preferCopilot: true }, controller.signal) || { ok: false, text: '', error: 'Agent not initialized' });
+                    const requestId = String(request.requestId || '');
+                    const onTextDelta = requestId
+                        ? (text) => {
+                            if (!controller.signal.aborted && !event.sender.isDestroyed())
+                                event.sender.send('agent:editorCompletionDelta', { requestId, text });
+                        }
+                        : undefined;
+                    return await (agent?.editorModelRequest({ ...request, completion: true, preferCopilot: true, onTextDelta }, controller.signal) || { ok: false, text: '', error: 'Agent not initialized' });
                 }
                 finally {
                     if (editorCompletionControllers.get(ownerId) === controller)
                         editorCompletionControllers.delete(ownerId);
                 }
             });
+            electron_1.ipcMain.handle('agent:editorCompleteCancel', async (event) => {
+                const ownerId = event.sender.id;
+                editorCompletionControllers.get(ownerId)?.abort(new Error('Editor completion cancelled'));
+                return { ok: true };
+            });
             electron_1.ipcMain.handle('agent:editorAssist', async (_event, request) => {
                 return agent?.editorModelRequest({ ...request, completion: false }) || { ok: false, text: '', error: 'Agent not initialized' };
             });
@@ -4605,6 +4754,7 @@ else {
                 })));
                 return { servers: mcpManager.list(), discovered };
             });
+            electron_1.ipcMain.handle('dsh:discover', async () => (0, dshCompatibility_1.discoverDshCompatibility)(root));
             electron_1.ipcMain.handle('mcp:upsert', async (_event, input) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
@@ -4619,12 +4769,14 @@ else {
             electron_1.ipcMain.handle('mcp:setEnabled', async (_event, id, enabled) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
-                return { ok: mcpManager.setEnabled(id, enabled), servers: mcpManager.list() };
+                const ok = mcpManager.setEnabled(id, enabled);
+                return { ok, error: ok ? undefined : 'MCP server was not found.', servers: mcpManager.list() };
             });
             electron_1.ipcMain.handle('mcp:remove', async (_event, id) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
-                return { ok: mcpManager.remove(id), servers: mcpManager.list() };
+                const ok = mcpManager.remove(id);
+                return { ok, error: ok ? undefined : 'MCP server was not found.', servers: mcpManager.list() };
             });
             electron_1.ipcMain.handle('memoryLab:read', async (_event, selector) => {
                 if (!agent)

package/dist/preload.js

@@ -12,6 +12,7 @@ contextBridge.exposeInMainWorld('api', {
     sendMessage: (message, target) => ipcRenderer.invoke('agent:send', message, target),
     enqueueGuide: (envelope) => ipcRenderer.invoke('agent:enqueueGuide', envelope),
     checkpointConversation: (request) => ipcRenderer.invoke('agent:checkpointConversation', request),
+    compressContext: (request) => ipcRenderer.invoke('agent:compressContext', request),
     rateAutoRoute: (request) => ipcRenderer.invoke('agent:rateAutoRoute', request),
     stopConversation: (request) => ipcRenderer.invoke('agent:stopConversation', request),
     setWorkRunExpanded: (request) => ipcRenderer.invoke('agent:setWorkRunExpanded', request),
@@ -32,12 +33,16 @@ contextBridge.exposeInMainWorld('api', {
     getConversationPlan: (conversationId) => ipcRenderer.invoke('agent:getConversationPlan', conversationId),
     updateConversationPlan: (plan, conversationId) => ipcRenderer.invoke('agent:updateConversationPlan', plan, conversationId),
     setConversationPinned: (id, pinned) => ipcRenderer.invoke('agent:setConversationPinned', id, pinned),
+    setConversationBranchCommunication: (target, enabled) => ipcRenderer.invoke('agent:setConversationBranchCommunication', target, enabled),
     renameConversation: (id, title) => ipcRenderer.invoke('agent:renameConversation', id, title),
     reorderConversations: (ids) => ipcRenderer.invoke('agent:reorderConversations', ids),
     browserRegisterGuest: (guestContentsId, target) => ipcRenderer.invoke('browser:registerGuest', guestContentsId, target),
     onBrowserEnsureGuest: (callback) => {
         ipcRenderer.on('browser:ensureGuest', (_event, target) => callback(target));
     },
+    onKeyboardCommand: (callback) => {
+        ipcRenderer.on('keyboard:command', (_event, payload) => callback(payload));
+    },
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
     computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
     setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
@@ -72,6 +77,10 @@ contextBridge.exposeInMainWorld('api', {
     readWorkspacePrompt: () => ipcRenderer.invoke('workspace:readPrompt'),
     saveWorkspacePrompt: (content) => ipcRenderer.invoke('workspace:savePrompt', content),
     editorComplete: (request) => ipcRenderer.invoke('agent:editorComplete', request),
+    editorCompleteCancel: () => ipcRenderer.invoke('agent:editorCompleteCancel'),
+    onEditorCompletionDelta: (callback) => {
+        ipcRenderer.on('agent:editorCompletionDelta', (_event, payload) => callback(payload));
+    },
     editorAssist: (request) => ipcRenderer.invoke('agent:editorAssist', request),
     filePathForFile: (file) => {
         try {
@@ -85,6 +94,7 @@ contextBridge.exposeInMainWorld('api', {
     selectFolder: () => ipcRenderer.invoke('dialog:selectFolder'),
     executeBash: (cmd, shell, cwd) => ipcRenderer.invoke('agent:executeBash', cmd, shell, cwd),
     openExternal: (path) => ipcRenderer.invoke('agent:openExternal', path),
+    openWebUrl: (url) => ipcRenderer.invoke('app:openWebUrl', url),
     selectWorkspace: (id) => ipcRenderer.invoke('agent:selectWorkspace', id),
     createWorkspace: (name) => ipcRenderer.invoke('agent:createWorkspace', name),
     createExternalWorkspace: (name, dirPath) => ipcRenderer.invoke('agent:createExternalWorkspace', name, dirPath),
@@ -113,6 +123,7 @@ contextBridge.exposeInMainWorld('api', {
     removeSkill: (name) => ipcRenderer.invoke('skills:remove', name),
     refreshSkills: () => ipcRenderer.invoke('skills:refresh'),
     listMcpServers: () => ipcRenderer.invoke('mcp:list'),
+    discoverDshCompatibility: () => ipcRenderer.invoke('dsh:discover'),
     upsertMcpServer: (input) => ipcRenderer.invoke('mcp:upsert', input),
     setMcpServerEnabled: (id, enabled) => ipcRenderer.invoke('mcp:setEnabled', id, enabled),
     removeMcpServer: (id) => ipcRenderer.invoke('mcp:remove', id),

package/dist/providers/chat-completions.adapter.js

@@ -48,6 +48,10 @@ class ChatCompletionsAdapter {
         };
         if (request.reasoningEffort)
             body.reasoning_effort = request.reasoningEffort;
+        // 会话标识透传：仅当上层（支持 session_id 语义的 provider）显式填充时写进
+        // body，否则省略，避免严格 API 拒绝未知字段。
+        if (request.sessionId)
+            body.session_id = request.sessionId;
         const base = request.baseUrl.replace(/\/+$/, '');
         return {
             url: `${base}/chat/completions`,
@@ -90,7 +94,10 @@ class ChatCompletionsAdapter {
         }
         const decoder = new TextDecoder();
         let buffer = '';
-        let currentToolCall = null;
+        const toolCalls = new Map();
+        const toolCallOrder = [];
+        let syntheticToolIndex = 0;
+        let lastToolIndex = 0;
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
@@ -137,32 +144,51 @@ class ChatCompletionsAdapter {
                         emittedContent = true;
                         yield { type: 'text.delta', delta: textDelta };
                     }
-                    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-                    for (const raw of toolCalls) {
+                    const deltaToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+                    for (const raw of deltaToolCalls) {
                         const tc = raw;
                         const fn = tc.function && typeof tc.function === 'object' ? tc.function : {};
-                        if (tc.id) {
-                            if (currentToolCall) {
-                                emittedTool = true;
-                                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
-                            }
+                        const rawIndex = Number(tc.index);
+                        const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                            ? rawIndex
+                            : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                        lastToolIndex = index;
+                        let currentToolCall = toolCalls.get(index);
+                        if (!currentToolCall && tc.id) {
                             currentToolCall = {
                                 id: String(tc.id || ''),
                                 name: (0, chat_messages_1.openAIToolName)(String(fn.name || '')),
-                                arguments: String(fn.arguments || ''),
+                                argumentParts: [],
                             };
+                            toolCalls.set(index, currentToolCall);
+                            toolCallOrder.push(index);
                             yield { type: 'tool_call.started', id: currentToolCall.id, name: currentToolCall.name };
                         }
-                        else if (fn.arguments && currentToolCall) {
-                            currentToolCall.arguments += String(fn.arguments);
-                            yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: String(fn.arguments) };
+                        if (currentToolCall && fn.name && !currentToolCall.name)
+                            currentToolCall.name = (0, chat_messages_1.openAIToolName)(String(fn.name));
+                        if (currentToolCall && fn.arguments !== undefined && fn.arguments !== null) {
+                            const argumentDelta = String(fn.arguments);
+                            if (argumentDelta) {
+                                currentToolCall.argumentParts.push(argumentDelta);
+                                yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: argumentDelta };
+                            }
                         }
                     }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                emittedTool = true;
-                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const currentToolCall = toolCalls.get(index);
+                    if (!currentToolCall)
+                        continue;
+                    emittedTool = true;
+                    yield {
+                        type: 'tool_call.completed',
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: currentToolCall.argumentParts.join(''),
+                    };
+                }
             }
             else if (!emittedContent && !emittedTool && contentPolicyBlocked) {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };

package/dist/providers/provider-adapter.d.ts

@@ -55,6 +55,9 @@ export interface NormalizedAgentRequest {
     reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     apiKey: string;
     baseUrl: string;
+    /** 可选的会话标识。仅当目标 provider 显式支持 session_id 语义的上下文缓存
+     *  时才由上层填充；adapter 在存在时透传，否则省略该字段（避免严格 API 拒绝未知字段）。 */
+    sessionId?: string;
 }
 export interface TokenEstimate {
     inputTokens: number;

package/dist/toolchain/registry/tool-registry.d.ts

@@ -1,4 +1,4 @@
-import { ToolDescriptor, ToolIdempotency, RiskLevel } from '../../context/domain/types';
+import { ToolDescriptor, ToolIdempotency, RiskLevel, ToolExecuteFn, ToolConcurrencySafeFn, ToolRenderFn, ToolPresentationMetaFn, ToolFinalizeContentFn, ToolPresentCallFn, ToolPresentResultFn } from '../../context/domain/types';
 export interface ToolDescriptorInput {
     toolId: string;
     capabilityId: string;
@@ -15,6 +15,18 @@ export interface ToolDescriptorInput {
     supportedScopes?: string[];
     cacheGroup?: string;
     implementationHash?: string;
+    /** DSH ToolDefinition.execute：命令式功能实现引用（cordis 核功能承载）。 */
+    execute?: ToolExecuteFn;
+    /** DSH ToolDefinition.isConcurrencySafe：运行时并发分类。 */
+    isConcurrencySafe?: ToolConcurrencySafeFn;
+    /** DSH ToolOutputDefinition.render / presentationMeta。 */
+    render?: ToolRenderFn;
+    presentationMeta?: ToolPresentationMetaFn;
+    /** DSH ToolDefinition.finalizeContent / timeoutMs / presentCall / presentResult。 */
+    finalizeContent?: ToolFinalizeContentFn;
+    timeoutMs?: number;
+    presentCall?: ToolPresentCallFn;
+    presentResult?: ToolPresentResultFn;
 }
 /**
  * Tool Registry: the authoritative set of ToolDescriptors. Schemas are

package/dist/toolchain/registry/tool-registry.js

@@ -28,6 +28,14 @@ class ToolRegistry {
             implementationHash: input.implementationHash,
             cacheGroup: input.cacheGroup || `${input.namespace}.${input.name}`,
             enabled: true,
+            execute: input.execute,
+            isConcurrencySafe: input.isConcurrencySafe,
+            render: input.render,
+            presentationMeta: input.presentationMeta,
+            finalizeContent: input.finalizeContent,
+            timeoutMs: input.timeoutMs,
+            presentCall: input.presentCall,
+            presentResult: input.presentResult,
         };
         this.tools.set(input.toolId, descriptor);
         return descriptor;

package/dist/toolchain/registry-seeder.js

@@ -60,15 +60,28 @@ function inferRiskLevel(name, description, annotations) {
         return 'external';
     if (READ_TOOL_PATTERN.test(name))
         return 'read';
+    // DSH 读工具命名惯例（get_/list_/query_/inspect_/read_ 前缀）：这些动词本质只读，
+    // 避免被启发式误判为 write（例如 DSH 的 get_goal / cordis_inspect_list）。
+    if (/^(get_|list_|query_|inspect_|read_)/.test(name) && !/_(create|update|set|write|delete|remove|run|execute|send|save|push|edit|toggle|define|stop|start)$/.test(name))
+        return 'read';
     return 'write';
 }
 function inferIdempotency(name) {
-    if (/^(bash|computer_use|browser_use|run|exec|execute|task)$/.test(name))
+    // shell 命令工具每次执行都可能改变外部状态，本质非幂等（DSH pwsh/bash/terminal 等）。
+    if (/^(bash|pwsh|powershell|cmd|shell|terminal|computer_use|browser_use|run|exec|execute|task)$/.test(name))
         return 'non_idempotent';
     if (/^(write|edit|append|send|save|create|update|set|put|register|patch)/.test(name))
         return 'conditionally_idempotent';
     return undefined;
 }
+/** 从真实 tool description 提取简洁 shortDescription（首句或截断），保 cordis 核可读。 */
+function compactDescription(description, fallback) {
+    const clean = String(description || '').replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return fallback;
+    const firstSentence = clean.split(/(?<=[.!?])\s+/)[0] || clean;
+    return firstSentence.slice(0, 120);
+}
 function resolveDefinition(definition) {
     if (!definition || typeof definition !== 'object')
         return null;
@@ -82,11 +95,35 @@ function resolveDefinition(definition) {
         };
     }
     if (typeof record.name === 'string') {
+        // 兼容两种字段名：Newmark 的 SeededToolDefinition 用 inputSchema，
+        // DSH 的 ToolSchema 用 parameters（dsh-llm ToolSchema：{name, description, parameters}）。
+        const rawParameters = record.inputSchema ?? record.parameters;
+        const rawExecute = record.execute;
+        const rawConcurrencySafe = record.isConcurrencySafe;
+        // DSH ToolOutputDefinition 是嵌套对象 {schema, render, presentationMeta}；
+        // outputSchema 从 output.schema 提取。
+        const rawOutput = record.output;
+        const outputSchema = record.outputSchema ?? rawOutput?.schema;
+        const render = rawOutput?.render;
+        const presentationMeta = rawOutput?.presentationMeta;
+        const finalizeContent = record.finalizeContent;
+        const timeoutMs = record.timeoutMs;
+        const presentCall = record.presentCall;
+        const presentResult = record.presentResult;
         return {
             name: record.name,
             description: typeof record.description === 'string' ? record.description : '',
-            parameters: record.inputSchema,
+            parameters: rawParameters,
+            outputSchema,
             annotations: record.annotations,
+            execute: typeof rawExecute === 'function' ? rawExecute : undefined,
+            isConcurrencySafe: typeof rawConcurrencySafe === 'function' ? rawConcurrencySafe : undefined,
+            render: typeof render === 'function' ? render : undefined,
+            presentationMeta: typeof presentationMeta === 'function' ? presentationMeta : undefined,
+            finalizeContent: typeof finalizeContent === 'function' ? finalizeContent : undefined,
+            timeoutMs: typeof timeoutMs === 'number' ? timeoutMs : undefined,
+            presentCall: typeof presentCall === 'function' ? presentCall : undefined,
+            presentResult: typeof presentResult === 'function' ? presentResult : undefined,
         };
     }
     return null;
@@ -135,7 +172,7 @@ function seedToolchainFromDefinitions(definitions, options) {
         if (riskLevel === 'destructive' || (riskLevel === 'external' && entry.input.riskLevel !== 'destructive')) {
             entry.input.riskLevel = riskLevel;
         }
-        entry.resolved.push({ name: definition.name, riskLevel, parameters: definition.parameters });
+        entry.resolved.push({ ...definition, riskLevel, domain });
     }
     for (const [domain, entry] of byDomain) {
         const requiredPermissions = entry.input.riskLevel === 'destructive'
@@ -166,13 +203,22 @@ function seedToolchainFromDefinitions(definitions, options) {
                 namespace,
                 name: tool.name,
                 version,
-                shortDescription: tool.name,
-                fullDescription: `${tool.name} (${domain})`,
+                shortDescription: compactDescription(tool.description, tool.name),
+                fullDescription: tool.description && tool.description.trim() ? tool.description : `${tool.name} (${domain})`,
                 inputSchema: tool.parameters ?? { type: 'object', properties: {}, required: [] },
+                outputSchema: tool.outputSchema,
                 riskLevel: tool.riskLevel,
                 idempotency,
                 requiredPermissions: required,
                 implementationHash: (0, deterministic_1.sha256)(tool.name),
+                execute: tool.execute,
+                isConcurrencySafe: tool.isConcurrencySafe,
+                render: tool.render,
+                presentationMeta: tool.presentationMeta,
+                finalizeContent: tool.finalizeContent,
+                timeoutMs: tool.timeoutMs,
+                presentCall: tool.presentCall,
+                presentResult: tool.presentResult,
             };
             core.registry.register(input);
             toolIds.push(tool.name);