@myagentroam/node 0.11.29 → 0.11.31

package/dist/connector.js

@@ -131,6 +131,7 @@ const HOSTED_CONVERSATION_OPERATIONS = [
     'conversation.hosted.rollback',
     'conversation.hosted.interrupt',
     'conversation.hosted.config.update',
+    'conversation.hosted.template.switch',
     'conversation.hosted.metadata.update',
     'conversation.hosted.image.read',
     'conversation.hosted.tool-resource.read',

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -30,10 +30,21 @@ export class MarAgentConversationNormalizer {
     #subagentDetails = new Map();
     #codeModeObservationIds = new Set();
     #codeModeSourceCallIds = new Set();
+    #toolOutputSnapshots = new Map();
+    #codeModeOutputCalls = new Map();
+    #codeModeOutputSnapshots = new Map();
+    #runningCodeModeCells = new Map();
+    #codeModeCellWaiters = new Map();
     messageItemId(nativeItemId) {
         return itemId('message', nativeItemId);
     }
     normalize(event, options = {}) {
+        if (event.type === 'tool.output')
+            return this.#toolOutput(event);
+        if (event.type === 'execution.started') {
+            this.#startExecution(event.executionId);
+            return [];
+        }
         if (event.type === 'input.received')
             return [this.input(event.entry)];
         if (event.type === 'execution.failed') {
@@ -93,15 +104,26 @@ export class MarAgentConversationNormalizer {
         if (event.type === 'tool.started' ||
             event.type === 'tool.completed' ||
             event.type === 'tool.failed') {
+            if (event.parentCallId !== undefined &&
+                (event.toolName === 'exec' || event.toolName === 'exec_wait')) {
+                if (event.type === 'tool.started')
+                    this.#trackCodeModeOutputCall(event);
+                else
+                    this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
+                return [];
+            }
             // Read/web calls and generated artifacts stay visible independently of cell observations.
             if (event.parentCallId !== undefined &&
                 event.toolName !== 'read' &&
                 event.toolName !== 'web_search' &&
                 event.toolName !== 'web_fetch' &&
-                !isImageGenerationTool(event.toolName))
+                !isImageGenerationTool(event.toolName)) {
+                this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
                 return [];
+            }
             if (event.type === 'tool.started')
                 return this.#toolStarted(event);
+            this.#finishToolCall(event);
             const permissionStop = permissionStopForToolEvent(event);
             const outerItems = event.type === 'tool.completed' ? this.#toolCompleted(event) : this.#toolFailed(event);
             return [
@@ -145,6 +167,10 @@ export class MarAgentConversationNormalizer {
     }
     #toolStarted(event) {
         const ownItemId = itemId('tool', event.callId);
+        this.#clearRetainedCodeModeCellsForOtherExecutions(event.executionId);
+        this.#toolOutputSnapshots.delete(event.callId);
+        this.#codeModeOutputCalls.delete(event.callId);
+        this.#clearCodeModeOutputSnapshots(event.callId);
         if (event.toolName === 'exec' || event.toolName === 'exec_wait') {
             const input = record(event.input) ?? {};
             const action = input.action ??
@@ -170,6 +196,9 @@ export class MarAgentConversationNormalizer {
                     input: event.input,
                     itemId: ownItemId,
                     structured: true,
+                    executionId: event.executionId,
+                    ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                    active: true,
                     commandOrigin: event.callId
                 });
                 return [commandItem(command, 'IN_PROGRESS')];
@@ -197,6 +226,9 @@ export class MarAgentConversationNormalizer {
                             input: event.input,
                             itemId: ownItemId,
                             structured: true,
+                            executionId: event.executionId,
+                            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                            active: true,
                             commandOrigin: event.callId
                         });
                         return [];
@@ -206,6 +238,9 @@ export class MarAgentConversationNormalizer {
                         input: event.input,
                         itemId: ownItemId,
                         structured: true,
+                        executionId: event.executionId,
+                        ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                        active: true,
                         commandOrigin: origin
                     });
                     return [];
@@ -222,16 +257,228 @@ export class MarAgentConversationNormalizer {
             input: event.input,
             itemId: ownItemId,
             structured: 'input' in event,
+            executionId: event.executionId,
+            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+            active: true,
             ...(event.data === undefined ? {} : { presentationData: event.data }),
             ...(subagentTitle === undefined ? {} : { subagentTitle }),
             ...(subagentDetails === undefined ? {} : { subagentDetails })
         });
+        if (event.toolName === 'code_exec_wait')
+            this.#trackCodeModeWait(event);
         if (event.toolName === 'apply_patch' && 'input' in event)
             return [fileChangeItem(ownItemId, 'IN_PROGRESS', [])];
         return [
             genericToolItem(ownItemId, event.toolName, 'IN_PROGRESS', event.input, null, null, event.truncated === true, event.data, subagentTitle, subagentDetails)
         ];
     }
+    #toolOutput(event) {
+        const { callId, toolName, executionId, turnId, parentCallId, output } = event;
+        const inputOutput = [output.stdout, output.stderr].filter(Boolean).join('\n');
+        const snapshot = {
+            outputPreview: compactRunnerText(inputOutput, 10_000),
+            truncated: output.truncated || inputOutput.length > 10_000
+        };
+        if (parentCallId !== undefined)
+            return this.#codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, output.processId, snapshot);
+        const state = this.#tools.get(callId);
+        if (state === undefined ||
+            !state.active ||
+            state.toolName !== toolName ||
+            state.executionId !== executionId ||
+            (state.turnId !== undefined && turnId !== undefined && state.turnId !== turnId) ||
+            state.commandOrigin === undefined)
+            return [];
+        const input = record(state.input);
+        if (typeof input?.processId === 'string' && input.processId !== output.processId)
+            return [];
+        const command = this.#commands.get(state.commandOrigin);
+        if (command === undefined || command.status !== 'IN_PROGRESS')
+            return [];
+        this.#toolOutputSnapshots.set(callId, {
+            commandOrigin: state.commandOrigin,
+            ...snapshot
+        });
+        return [
+            commandItem(commandWithOutputSnapshots(command, [...this.#toolOutputSnapshots.values()].filter((entry) => entry.commandOrigin === state.commandOrigin)), 'IN_PROGRESS')
+        ];
+    }
+    #codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, processId, snapshot) {
+        const parent = this.#tools.get(parentCallId);
+        const child = this.#codeModeOutputCalls.get(callId);
+        if (parent === undefined ||
+            (parent.toolName !== 'code_exec' && parent.toolName !== 'code_exec_wait') ||
+            parent.executionId !== executionId ||
+            (parent.turnId !== undefined && turnId !== undefined && parent.turnId !== turnId) ||
+            child === undefined ||
+            child.parentCallId !== parentCallId ||
+            child.toolName !== toolName ||
+            child.executionId !== executionId ||
+            (child.turnId !== undefined && turnId !== undefined && child.turnId !== turnId))
+            return [];
+        const target = parent.active
+            ? parent
+            : this.#runningCodeModeCells.get(parentCallId)?.executionId === executionId
+                ? this.#activeCodeModeWaiter(this.#runningCodeModeCells.get(parentCallId))
+                : undefined;
+        if (target === undefined)
+            return [];
+        const input = record(child.input);
+        if (typeof input?.processId === 'string' && input.processId !== processId)
+            return [];
+        const snapshots = this.#codeModeOutputSnapshots.get(parentCallId) ?? new Map();
+        snapshots.set(callId, snapshot);
+        this.#codeModeOutputSnapshots.set(parentCallId, snapshots);
+        const combined = [...snapshots.values()]
+            .map((entry) => entry.outputPreview)
+            .filter(Boolean)
+            .join('\n');
+        const truncated = [...snapshots.values()].some((entry) => entry.truncated) || combined.length > 10_000;
+        return [
+            genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, compactRunnerText(combined, 10_000), null, truncated)
+        ];
+    }
+    #trackCodeModeOutputCall(event) {
+        const parentCallId = event.parentCallId;
+        if (parentCallId === undefined || (event.toolName !== 'exec' && event.toolName !== 'exec_wait'))
+            return;
+        const parent = this.#tools.get(parentCallId);
+        const retainedCell = this.#runningCodeModeCells.get(parentCallId);
+        const canResumeRetainedCell = parent !== undefined && !parent.active && retainedCell?.executionId === event.executionId;
+        if (parent === undefined ||
+            (parent.toolName !== 'code_exec' && parent.toolName !== 'code_exec_wait') ||
+            parent.executionId !== event.executionId ||
+            (parent.turnId !== undefined && event.turnId !== undefined && parent.turnId !== event.turnId))
+            return;
+        if (!parent.active && !canResumeRetainedCell)
+            return;
+        this.#codeModeOutputCalls.delete(event.callId);
+        const snapshots = this.#codeModeOutputSnapshots.get(parentCallId);
+        snapshots?.delete(event.callId);
+        this.#codeModeOutputCalls.set(event.callId, {
+            parentCallId,
+            executionId: event.executionId,
+            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+            toolName: event.toolName,
+            input: event.input
+        });
+    }
+    #finishCodeModeOutputCall(callId, parentCallId) {
+        const call = this.#codeModeOutputCalls.get(callId);
+        if (call?.parentCallId === parentCallId) {
+            this.#codeModeOutputCalls.delete(callId);
+            this.#codeModeOutputSnapshots.get(parentCallId)?.delete(callId);
+        }
+    }
+    #trackCodeModeWait(event) {
+        const cellId = record(event.input)?.cellId;
+        if (typeof cellId !== 'string' || cellId.length === 0)
+            return;
+        const cell = [...this.#runningCodeModeCells.values()].find((candidate) => candidate.cellId === cellId && candidate.executionId === event.executionId);
+        if (cell === undefined)
+            return;
+        const waiters = this.#codeModeCellWaiters.get(cellId) ?? new Set();
+        waiters.add(event.callId);
+        this.#codeModeCellWaiters.set(cellId, waiters);
+    }
+    #activeCodeModeWaiter(cell) {
+        const waiters = this.#codeModeCellWaiters.get(cell.cellId);
+        if (waiters === undefined)
+            return undefined;
+        for (const callId of [...waiters].reverse()) {
+            const state = this.#tools.get(callId);
+            const input = record(state?.input);
+            if (state?.active === true &&
+                state.toolName === 'code_exec_wait' &&
+                state.executionId === cell.executionId &&
+                input?.cellId === cell.cellId)
+                return state;
+            waiters.delete(callId);
+        }
+        if (waiters.size === 0)
+            this.#codeModeCellWaiters.delete(cell.cellId);
+        return undefined;
+    }
+    #finishToolCall(event) {
+        const state = this.#tools.get(event.callId);
+        if (state !== undefined)
+            state.active = false;
+        this.#toolOutputSnapshots.delete(event.callId);
+        const data = record(event.data);
+        const cellId = typeof data?.cellId === 'string' ? data.cellId : undefined;
+        const status = data?.status;
+        if (state?.toolName === 'code_exec') {
+            if (event.type === 'tool.completed' &&
+                event.toolName === 'code_exec' &&
+                status === 'running' &&
+                cellId !== undefined &&
+                cellId.length > 0) {
+                this.#runningCodeModeCells.set(event.callId, {
+                    cellId,
+                    executionId: event.executionId
+                });
+                return;
+            }
+            this.#clearRunningCodeModeCell(event.callId);
+            return;
+        }
+        if (state?.toolName === 'code_exec_wait') {
+            const inputCellId = record(state.input)?.cellId;
+            if (typeof inputCellId === 'string')
+                this.#removeCodeModeWaiter(inputCellId, event.callId);
+            if ((status === 'completed' || status === 'failed' || status === 'cancelled') &&
+                typeof (cellId ?? inputCellId) === 'string') {
+                const finishedCellId = (cellId ?? inputCellId);
+                for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+                    if (cell.cellId === finishedCellId && cell.executionId === event.executionId)
+                        this.#clearRunningCodeModeCell(sourceCallId);
+            }
+            this.#clearCodeModeOutputSnapshots(event.callId);
+            return;
+        }
+        this.#clearCodeModeOutputSnapshots(event.callId);
+    }
+    #clearCodeModeOutputSnapshots(parentCallId) {
+        this.#codeModeOutputSnapshots.delete(parentCallId);
+        for (const [callId, state] of this.#codeModeOutputCalls)
+            if (state.parentCallId === parentCallId)
+                this.#codeModeOutputCalls.delete(callId);
+    }
+    #removeCodeModeWaiter(cellId, callId) {
+        const waiters = this.#codeModeCellWaiters.get(cellId);
+        waiters?.delete(callId);
+        if (waiters?.size === 0)
+            this.#codeModeCellWaiters.delete(cellId);
+    }
+    #clearRunningCodeModeCell(sourceCallId) {
+        const cell = this.#runningCodeModeCells.get(sourceCallId);
+        if (cell !== undefined) {
+            this.#runningCodeModeCells.delete(sourceCallId);
+            this.#codeModeCellWaiters.delete(cell.cellId);
+        }
+        this.#clearCodeModeOutputSnapshots(sourceCallId);
+    }
+    #startExecution(executionId) {
+        for (const [callId, state] of this.#tools)
+            if (state.executionId !== executionId) {
+                state.active = false;
+                this.#toolOutputSnapshots.delete(callId);
+            }
+        for (const [callId, state] of this.#codeModeOutputCalls)
+            if (state.executionId !== executionId)
+                this.#codeModeOutputCalls.delete(callId);
+        for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+            if (cell.executionId !== executionId)
+                this.#clearRunningCodeModeCell(sourceCallId);
+        for (const parentCallId of this.#codeModeOutputSnapshots.keys())
+            if (this.#tools.get(parentCallId)?.executionId !== executionId)
+                this.#codeModeOutputSnapshots.delete(parentCallId);
+    }
+    #clearRetainedCodeModeCellsForOtherExecutions(executionId) {
+        for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+            if (cell.executionId !== executionId)
+                this.#clearRunningCodeModeCell(sourceCallId);
+    }
     #compactAnchorItemId(event, publicItemIdPrefix) {
         const anchor = event.anchor;
         if (anchor === undefined || !validCompactAnchor(anchor.id))
@@ -730,6 +977,21 @@ function commandItem(command, status, title) {
         merge: true
     };
 }
+function commandWithOutputSnapshots(command, snapshots) {
+    const outputPreview = [
+        command.outputPreview,
+        ...snapshots.map((snapshot) => snapshot.outputPreview)
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return {
+        ...command,
+        outputPreview: compactRunnerText(outputPreview, 10_000),
+        truncated: command.truncated ||
+            snapshots.some((snapshot) => snapshot.truncated) ||
+            outputPreview.length > 10_000
+    };
+}
 function applyCommandResult(command, result) {
     const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
     if (output.length > 0) {

package/dist/service/hosted-conversation-node-service.js

@@ -6,7 +6,7 @@ import { randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
 import { lstat, mkdir, open, readFile, rename, rm, utimes } from 'node:fs/promises';
 import { join } from 'node:path';
-import { toolResultResourceInputSchema, toolResultResourcePageSchema, conversationTurnSchema, conversationTemplateSummarySchema, hostedConversationConfigUpdateInputSchema, hostedConversationCreateInputSchema, hostedConversationDeleteResultSchema, hostedConversationFileDeleteInputSchema, hostedConversationFileDeleteResultSchema, hostedConversationFileReadInputSchema, hostedConversationFileReadResultSchema, hostedConversationFilesSchema, hostedConversationHistoryInputSchema, hostedConversationHistoryPageSchema, hostedConversationIdInputSchema, hostedConversationImageReadInputSchema, hostedConversationListInputSchema, hostedConversationListPageSchema, hostedConversationMessageInputSchema, hostedConversationMetadataUpdateInputSchema, hostedConversationModelOptionsInputSchema, hostedConversationModelOptionsSchema, hostedConversationRollbackInputSchema, hostedConversationSnapshotSchema, hostedConversationSummarySchema, hostedConversationUnwatchInputSchema, hostedConversationUploadChunkInputSchema, hostedConversationUploadControlInputSchema, hostedConversationUploadCreateInputSchema, hostedConversationUploadPreflightInputSchema, hostedConversationUploadPreflightResultSchema, hostedConversationUploadSchema, hostedConversationWatchInputSchema, marAgentRuntimeModelConfigurationSchema, resolveMarAgentDefaultReasoningEffort } from '@myagentroam/protocol';
+import { toolResultResourceInputSchema, toolResultResourcePageSchema, conversationTurnSchema, conversationTemplateSummarySchema, hostedConversationConfigUpdateInputSchema, hostedConversationTemplateSwitchInputSchema, hostedConversationTemplateSwitchResultSchema, hostedConversationCreateInputSchema, hostedConversationDeleteResultSchema, hostedConversationFileDeleteInputSchema, hostedConversationFileDeleteResultSchema, hostedConversationFileReadInputSchema, hostedConversationFileReadResultSchema, hostedConversationFilesSchema, hostedConversationHistoryInputSchema, hostedConversationHistoryPageSchema, hostedConversationIdInputSchema, hostedConversationImageReadInputSchema, hostedConversationListInputSchema, hostedConversationListPageSchema, hostedConversationMessageInputSchema, hostedConversationMetadataUpdateInputSchema, hostedConversationModelOptionsInputSchema, hostedConversationModelOptionsSchema, hostedConversationRollbackInputSchema, hostedConversationSnapshotSchema, hostedConversationSummarySchema, hostedConversationUnwatchInputSchema, hostedConversationUploadChunkInputSchema, hostedConversationUploadControlInputSchema, hostedConversationUploadCreateInputSchema, hostedConversationUploadPreflightInputSchema, hostedConversationUploadPreflightResultSchema, hostedConversationUploadSchema, hostedConversationWatchInputSchema, marAgentRuntimeModelConfigurationSchema, resolveMarAgentDefaultReasoningEffort } from '@myagentroam/protocol';
 import { hostedConversationGeneratedImagesDisplayDirectory, hostedConversationImageRunId, marAgentGeneratedImagesDirectory } from '../runner/mar-agent/generated-images.js';
 import { sessionTitleFromFirstMessage } from '../util/node-operation-parsers.js';
 import { safeErrorCode } from '../util/safe-error.js';
@@ -62,6 +62,7 @@ export class HostedConversationNodeService {
             'conversation.hosted.rollback': (raw) => this.rollback(raw),
             'conversation.hosted.interrupt': (raw) => this.interrupt(raw),
             'conversation.hosted.config.update': (raw) => this.updateConfiguration(raw),
+            'conversation.hosted.template.switch': (raw) => this.switchTemplate(raw),
             'conversation.hosted.metadata.update': (raw) => this.updateMetadata(raw),
             'conversation.hosted.image.read': (raw) => this.readImage(raw),
             'conversation.hosted.tool-resource.read': (raw) => this.readToolResource(raw),
@@ -147,8 +148,11 @@ export class HostedConversationNodeService {
         if (pending !== undefined)
             return pending;
         const existing = this.options.store.findConversationByClientRequest(payload.userId, input.clientRequestId);
-        if (existing !== undefined)
+        if (existing !== undefined) {
+            if (existing.templateId !== input.templateId)
+                throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
             return this.snapshot(payload.userId, existing.id, models);
+        }
         const operation = this.createConversation(payload.userId, input.clientRequestId, template, models, input.modelId, payload.runtimeScopeId);
         this.pendingCreates.set(key, operation);
         void operation.finally(() => this.pendingCreates.delete(key)).catch(() => undefined);
@@ -233,7 +237,8 @@ export class HostedConversationNodeService {
     async get(raw) {
         const payload = hostedRequest(raw);
         const input = hostedConversationIdInputSchema.parse(payload.data);
-        return this.snapshot(payload.userId, input.conversationId, runtimeModels(payload.models), payload.templateDeleted);
+        this.assertTemplateContext(payload, this.options.store.requireConversation(payload.userId, input.conversationId));
+        return this.snapshot(payload.userId, input.conversationId, runtimeModels(payload.models), payload.templateDeleted, false, undefined, payload.sourceTemplateId);
     }
     async history(raw) {
         const payload = hostedRequest(raw);
@@ -250,9 +255,9 @@ export class HostedConversationNodeService {
         });
         return hostedConversationHistoryPageSchema.parse(page);
     }
-    async snapshot(userId, conversationId, availableModels, templateDeleted = false, includeActiveHistoryMutation = false, historyOverride) {
+    async snapshot(userId, conversationId, availableModels, templateDeleted = false, includeActiveHistoryMutation = false, historyOverride, sourceTemplateId) {
         if (includeActiveHistoryMutation)
-            return this.readSnapshot(userId, conversationId, availableModels, templateDeleted, historyOverride);
+            return this.readSnapshot(userId, conversationId, availableModels, templateDeleted, historyOverride, sourceTemplateId);
         while (true) {
             const version = this.historyVersions.get(conversationId) ?? 0;
             const mutation = this.historyMutations.get(conversationId);
@@ -260,16 +265,20 @@ export class HostedConversationNodeService {
                 await mutation.catch(() => undefined);
                 continue;
             }
-            const snapshot = await this.readSnapshot(userId, conversationId, availableModels, templateDeleted);
+            const snapshot = await this.readSnapshot(userId, conversationId, availableModels, templateDeleted, undefined, sourceTemplateId);
             if (!this.historyMutations.has(conversationId) &&
                 (this.historyVersions.get(conversationId) ?? 0) === version)
                 return snapshot;
         }
     }
-    async readSnapshot(userId, conversationId, availableModels, templateDeleted, historyOverride) {
+    async readSnapshot(userId, conversationId, availableModels, templateDeleted, historyOverride, sourceTemplateId) {
         let conversation = this.options.store.requireConversation(userId, conversationId);
+        if (sourceTemplateId !== undefined && conversation.templateId !== sourceTemplateId)
+            throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
+        const templateId = conversation.templateId;
+        const activeVersionId = conversation.activeVersionId;
         if (templateDeleted)
-            conversation = await this.options.store.retainConversationTemplate(userId, conversationId, this.now());
+            conversation = await this.options.store.retainConversationTemplate(userId, conversationId, this.now(), sourceTemplateId ?? templateId);
         const latestVersionId = conversation.templateDeleted
             ? undefined
             : this.latestAvailableTemplateVersionId(conversation.templateId);
@@ -282,7 +291,11 @@ export class HostedConversationNodeService {
             const configuredModelId = conversation.modelId;
             const selected = selectModel(version, availableModels, conversation.modelId);
             if (selected.id !== conversation.modelId)
-                conversation = await this.options.store.updateConversation(conversation.id, (current) => current.modelId === configuredModelId ? { ...current, modelId: selected.id } : current);
+                conversation = await this.options.store.updateConversation(conversation.id, (current) => current.templateId === templateId &&
+                    current.activeVersionId === activeVersionId &&
+                    current.modelId === configuredModelId
+                    ? { ...current, modelId: selected.id }
+                    : current);
         }
         const paths = this.options.store.pathsForConversation(userId, conversation.id);
         const history = historyOverride ??
@@ -293,6 +306,9 @@ export class HostedConversationNodeService {
                 modelId: conversation.modelId,
                 limit: 10
             }));
+        const current = this.options.store.requireConversation(userId, conversationId);
+        if (current.templateId !== templateId || current.activeVersionId !== activeVersionId)
+            throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
         return hostedConversationSnapshotSchema.parse({
             nodeAppVersion: this.options.nodeAppVersion?.() ?? 'unknown',
             conversation: this.summary(conversation),
@@ -312,6 +328,7 @@ export class HostedConversationNodeService {
         const payload = hostedRequest(raw);
         const input = hostedConversationWatchInputSchema.parse(payload.data);
         const conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
+        this.assertTemplateContext(payload, conversation);
         if (this.cleanupLocks.has(conversation.id))
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
         const sessionHash = requireWatchSessionHash(payload.sessionHash);
@@ -479,6 +496,7 @@ export class HostedConversationNodeService {
             return Promise.reject(new Error('CONVERSATION_HOSTING_UNAVAILABLE'));
         const payload = hostedRequest(raw);
         const input = hostedConversationMessageInputSchema.parse(payload.data);
+        this.assertTemplateContext(payload, this.options.store.requireConversation(payload.userId, input.conversationId));
         if (this.historyMutations.has(input.conversationId))
             return Promise.reject(new Error('HOSTED_CONVERSATION_STATE_INVALID'));
         const key = `${input.conversationId}\0${input.clientMessageId}`;
@@ -561,6 +579,7 @@ export class HostedConversationNodeService {
     }
     async startMessage(payload, input, steerPrompt) {
         let conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
+        this.assertTemplateContext(payload, conversation);
         if (this.cleanupLocks.has(conversation.id))
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
         if (this.historyMutations.has(conversation.id))
@@ -770,6 +789,7 @@ export class HostedConversationNodeService {
         const payload = hostedRequest(raw);
         const input = hostedConversationRollbackInputSchema.parse(payload.data);
         const conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
+        this.assertTemplateContext(payload, conversation);
         if (conversation.status !== 'ACTIVE' ||
             this.cleanupLocks.has(conversation.id) ||
             this.historyMutations.has(conversation.id))
@@ -942,10 +962,94 @@ export class HostedConversationNodeService {
             throw error;
         }
     }
-    async updateConfiguration(raw) {
+    switchTemplate(raw) {
+        if (this.closing || this.disablePrepared)
+            throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
+        const payload = hostedRequest(raw);
+        const input = hostedConversationTemplateSwitchInputSchema.parse(payload.data);
+        const conversation = this.requireWritableConversation(payload.userId, input.conversationId);
+        if (this.fileWrites.has(conversation.id) ||
+            [...this.uploads.values()].some((upload) => upload.conversationId === conversation.id && upload.status === 'UPLOADING'))
+            throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
+        if (this.activeRuns.has(conversation.id) ||
+            this.runSettlements.has(conversation.id) ||
+            [...this.pendingMessages.keys()].some((key) => key.startsWith(`${conversation.id}\0`)))
+            throw new Error('HOSTED_CONVERSATION_RUN_ACTIVE');
+        const template = conversationTemplateSummarySchema.parse(payload.template);
+        if (template.id !== input.templateId ||
+            template.nodeId !== conversation.nodeId ||
+            template.status !== 'ACTIVE' ||
+            !template.available ||
+            template.currentVersionId === null)
+            throw new Error('HOSTED_CONVERSATION_TEMPLATE_UNAVAILABLE');
+        return this.withConversationChange(conversation.id, async () => {
+            const current = this.options.store.requireConversation(payload.userId, conversation.id);
+            const unchanged = current.templateId === input.templateId;
+            if (!unchanged && current.templateId !== input.expectedTemplateId)
+                throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
+            const version = await this.loadTemplateVersion(unchanged ? current.activeVersionId : template.currentVersionId, template.id);
+            const models = networkModels(allowedModels(version, runtimeModels(payload.models)), version.draft.networkMode).filter((model) => model.conversationModel !== false);
+            let saved = current;
+            if (!unchanged) {
+                const selected = selectModel(version, models, current.modelId);
+                resolveMcpServers(version, this.options.secretEnvironment ?? process.env);
+                const paths = this.options.store.pathsForConversation(payload.userId, current.id);
+                this.pathMounts(paths, version);
+                this.processExecutor(paths, version);
+                if (current.quota.usedBytes > version.draft.quotas.maxStorageBytes)
+                    throw new Error('HOSTED_CONVERSATION_QUOTA_EXCEEDED');
+                const updatedAt = this.now();
+                saved = await this.options.store.updateConversation(current.id, (latest) => ({
+                    ...latest,
+                    templateId: template.id,
+                    templateName: template.name,
+                    templateDeleted: false,
+                    activeVersionId: version.id,
+                    modelId: selected.id,
+                    quota: { ...latest.quota, maxBytes: version.draft.quotas.maxStorageBytes },
+                    updatedAt,
+                    lastActivityAt: updatedAt
+                }));
+                try {
+                    this.publishHostedEvent(saved.id, { conversationId: saved.id, kind: 'template-changed' });
+                }
+                catch {
+                    // Committed configuration does not depend on best-effort Watch delivery.
+                }
+                finally {
+                    for (const [key, lease] of this.watchLeases)
+                        if (lease.conversationId === saved.id)
+                            this.removeWatchLease(key);
+                }
+            }
+            return hostedConversationTemplateSwitchResultSchema.parse({
+                conversation: this.summary(saved),
+                template: templateSummary(saved, version.draft),
+                models: models.map(modelSummary)
+            });
+        });
+    }
+    withConversationChange(conversationId, change) {
+        if (this.historyMutations.has(conversationId))
+            throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
+        const operation = Promise.resolve().then(change);
+        this.historyMutations.set(conversationId, operation);
+        void operation
+            .finally(() => {
+            if (this.historyMutations.get(conversationId) === operation)
+                this.historyMutations.delete(conversationId);
+        })
+            .catch(() => undefined);
+        return operation;
+    }
+    updateConfiguration(raw) {
         const payload = hostedRequest(raw);
         const input = hostedConversationConfigUpdateInputSchema.parse(payload.data);
-        const conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
+        const conversation = this.requireWritableConversation(payload.userId, input.conversationId);
+        this.assertTemplateContext(payload, conversation);
+        return this.withConversationChange(conversation.id, () => this.saveConfiguration(payload, input, conversation));
+    }
+    async saveConfiguration(payload, input, conversation) {
         if (this.cleanupLocks.has(conversation.id))
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
         const latestVersionId = conversation.templateDeleted
@@ -1337,6 +1441,7 @@ export class HostedConversationNodeService {
             const snapshot = await this.get({
                 conversationId: lease.conversationId,
                 __requestUserId: lease.userId,
+                __sourceTemplateId: lease.templateId,
                 __marAgentModels: lease.models
             });
             if (this.watchLeases.get(lease.ownerKey) !== lease)
@@ -1559,12 +1664,17 @@ export class HostedConversationNodeService {
     }
     requireWritableConversation(userId, conversationId) {
         const conversation = this.options.store.requireConversation(userId, conversationId);
-        if (this.cleanupLocks.has(conversation.id))
+        if (this.cleanupLocks.has(conversation.id) || this.historyMutations.has(conversation.id))
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
         if (conversation.status !== 'ACTIVE')
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
         return conversation;
     }
+    assertTemplateContext(payload, conversation) {
+        if (payload.sourceTemplateId !== undefined &&
+            payload.sourceTemplateId !== conversation.templateId)
+            throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
+    }
     requireUpload(userId, conversationId, uploadId) {
         this.options.store.requireConversation(userId, conversationId);
         const upload = this.uploads.get(uploadId);
@@ -1800,18 +1910,22 @@ export class HostedConversationNodeService {
 function hostedRequest(raw) {
     if (!record(raw))
         throw new Error('HOSTED_CONVERSATION_NOT_AUTHORIZED');
-    const { __usageGrant, __requestUserId, __template, __marAgentModel, __marAgentModels, __marAgentCompact, __marAgentRuntimeScopeId, __workspaceWatchSessionHash, __templateDeleted, ...data } = raw;
+    const { __usageGrant, __requestUserId, __template, __marAgentModel, __marAgentModels, __marAgentCompact, __marAgentRuntimeScopeId, __workspaceWatchSessionHash, __templateDeleted, __sourceTemplateId, ...data } = raw;
     if (typeof __requestUserId !== 'number' ||
         !Number.isSafeInteger(__requestUserId) ||
         __requestUserId <= 0)
         throw new Error('HOSTED_CONVERSATION_NOT_AUTHORIZED');
     if (__templateDeleted !== undefined && __templateDeleted !== true)
         throw new Error('HOSTED_CONVERSATION_NOT_AUTHORIZED');
+    if (__sourceTemplateId !== undefined &&
+        (typeof __sourceTemplateId !== 'string' || __sourceTemplateId.length === 0))
+        throw new Error('HOSTED_CONVERSATION_NOT_AUTHORIZED');
     if (__marAgentRuntimeScopeId !== undefined &&
         (typeof __marAgentRuntimeScopeId !== 'string' || __marAgentRuntimeScopeId.length === 0))
         throw new Error('HOSTED_CONVERSATION_NOT_AUTHORIZED');
     return {
         data,
+        ...(__sourceTemplateId === undefined ? {} : { sourceTemplateId: __sourceTemplateId }),
         ...(__usageGrant === undefined
             ? {}
             : { usageGrant: modelUsageGrantSchema.parse(__usageGrant) }),

package/dist/service/hosted-conversation-store.js

@@ -385,10 +385,15 @@ export class HostedConversationStore {
         await this.writeManifest(paths.manifestPath, manifest);
         return manifest;
     }
-    async retainConversationTemplate(userId, conversationId, updatedAt) {
+    async retainConversationTemplate(userId, conversationId, updatedAt, expectedTemplateId) {
+        return this.withConversationMutation(conversationId, () => this.retainConversationTemplateUnlocked(userId, conversationId, updatedAt, expectedTemplateId));
+    }
+    async retainConversationTemplateUnlocked(userId, conversationId, updatedAt, expectedTemplateId) {
         if (!Number.isSafeInteger(updatedAt) || updatedAt < 0)
             throw new Error('HOSTED_CONVERSATION_INPUT_INVALID');
         const current = this.requireConversation(userId, conversationId);
+        if (expectedTemplateId !== undefined && current.templateId !== expectedTemplateId)
+            throw new Error('HOSTED_CONVERSATION_TEMPLATE_CONFLICT');
         const version = this.options.database.raw
             .prepare('SELECT status FROM conversation_template_versions WHERE id=? AND template_id=?')
             .get(current.activeVersionId, current.templateId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.29",
+  "version": "0.11.31",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -38,10 +38,10 @@
     "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.29",
+    "@myagentroam/agent": "0.11.31",
     "@myagentroam/code-navigation": "0.11.0",
-    "@myagentroam/protocol": "0.11.29",
-    "@myagentroam/marctl": "0.11.1"
+    "@myagentroam/marctl": "0.11.1",
+    "@myagentroam/protocol": "0.11.31"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"