@myagentroam/node 0.11.36 → 0.11.38

package/dist/runner/mar-agent/hosted-conversation-runtime.js

@@ -245,33 +245,29 @@ export class MarAgentHostedConversationRuntime {
                     clientMessageId: request.clientMessageId
                 });
             },
-            cancel: () => {
+            cancel: (reason = 'interrupt') => {
                 if (settled || this.#active.get(input.sessionId)?.handle !== handle)
                     return false;
+                if (reason === 'shutdown')
+                    titleController.abort();
                 execution.cancel();
                 return true;
             }
         };
-        this.#active.set(input.sessionId, {
-            handle,
-            completion,
-            cancelTitle: () => titleController.abort()
-        });
+        this.#active.set(input.sessionId, { handle, completion });
         return handle;
     }
     async releaseSession(input) {
         const active = this.#active.get(input.sessionId);
         if (active === undefined)
             return;
-        active.cancelTitle();
-        active.handle.cancel();
+        active.handle.cancel('shutdown');
         await active.completion.catch(() => undefined);
     }
     async dispose() {
         const active = [...this.#active.values()];
         for (const execution of active) {
-            execution.cancelTitle();
-            execution.handle.cancel();
+            execution.handle.cancel('shutdown');
         }
         await Promise.allSettled(active.map((execution) => execution.completion));
     }

package/dist/runner/mar-agent/managed-run-controller.js

@@ -8,12 +8,12 @@ import { homedir } from 'node:os';
 import { nodeLog } from '../../operational.js';
 import { createAgent, generateSessionTitle } from '@myagentroam/agent';
 import { marAgentReasoningEffortSchema, resolveMarAgentDefaultReasoningEffort } from '@myagentroam/protocol';
-import { boundedConversationItemId } from '../../util/node-operation-parsers.js';
-import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { boundedConversationItemId } from '../normalization.js';
+import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
 import { MarAgentMcpClientCache } from './mcp-client-pool.js';
 import { MarAgentConversationNormalizer, normalizeMarAgentUsage } from './conversation-normalizer.js';
-import { parseRunnerImageAttachments } from '../../util/node-operation-parsers.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { parseRunnerImageAttachments } from '../../session/attachments.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredentialProviders } from './runtime-model-factory.js';
 import { createImageGenerationExtensions } from './image-generation-extensions.js';
 import { createWebToolsExtensions } from './web-tools-extensions.js';
@@ -111,7 +111,9 @@ export class MarAgentManagedRunController {
         if (session.externalSessionId === null || session.nativeControl !== 'MAR_MANAGED')
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const execution = context.executionContext;
-        const resolved = resolveMarAgentExecutionInput(execution?.runner === 'mar-agent' ? execution.runnerInput : undefined, session.model ?? '');
+        const resolved = resolveMarAgentExecutionInput(execution?.runner === 'mar-agent'
+            ? execution.runnerInput
+            : undefined, session.model ?? '');
         if (resolved === undefined)
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const runId = randomUUID();
@@ -149,7 +151,7 @@ export class MarAgentManagedRunController {
             typeof payload.input !== 'string' ||
             typeof payload.cwd !== 'string' ||
             typeof payload.model !== 'string' ||
-            this.host.active.has(payload.runId))
+            this.host.isExecutionActive(payload.runId))
             return;
         const resolved = resolveMarAgentExecutionInput(marAgentEnvelopeInput(payload), payload.model);
         if (resolved === undefined) {
@@ -242,7 +244,7 @@ export class MarAgentManagedRunController {
         this.#executions.set(input.runId, execution);
         let runtime;
         let use;
-        let terminalPublished = false;
+        let terminalEvent;
         let executionMcpLease;
         let executionMcpBinding;
         let computerUseBinding;
@@ -250,7 +252,7 @@ export class MarAgentManagedRunController {
         let titleTask;
         let cancelledDuringPreparation = false;
         try {
-            this.host.active.add(input.runId);
+            this.host.executionAccepted(input.runId);
             this.host.adopt({
                 runId: input.runId,
                 sessionId: input.sessionId,
@@ -419,34 +421,44 @@ export class MarAgentManagedRunController {
                         : result;
                 });
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
-            for await (const event of handle) {
-                if (event.type === 'execution.started' && metadata?.automaticTitlePending && !titleTask) {
-                    titleTask = this.#generateTitle({
-                        models: sdkModelConfigurations(executionModels),
-                        currentModelId: input.model.id,
-                        prompt: input.input,
-                        onModelUsage: (usage) => this.host.emit(input.runId, 'run.usage', normalizeMarAgentUsage({
-                            ...usage,
-                            sessionId: session.id,
-                            executionId: handle.executionId,
-                            purpose: 'title',
-                            agentRole: 'root'
-                        })),
-                        signal: titleController.signal
-                    }).catch((error) => {
-                        if (!titleController.signal.aborted)
-                            nodeLog('runner.mar-agent.title.failed', {
+            const consumeEvents = async () => {
+                for await (const event of handle) {
+                    if (event.type === 'execution.started' && metadata?.automaticTitlePending && !titleTask) {
+                        titleTask = this.#generateTitle({
+                            models: sdkModelConfigurations(executionModels),
+                            currentModelId: input.model.id,
+                            prompt: input.input,
+                            onModelUsage: (usage) => this.host.emit(input.runId, 'run.usage', normalizeMarAgentUsage({
+                                ...usage,
                                 sessionId: session.id,
-                                runId: input.runId,
-                                stage: 'generate',
-                                code: runnerErrorProjection(error, 'MAR_AGENT_TITLE_GENERATION_FAILED').code
-                            });
-                        return undefined;
-                    });
+                                executionId: handle.executionId,
+                                purpose: 'title',
+                                agentRole: 'root'
+                            })),
+                            signal: titleController.signal
+                        }).catch((error) => {
+                            if (!titleController.signal.aborted)
+                                nodeLog('runner.mar-agent.title.failed', {
+                                    sessionId: session.id,
+                                    runId: input.runId,
+                                    stage: 'generate',
+                                    code: runnerErrorProjection(error, 'MAR_AGENT_TITLE_GENERATION_FAILED').code
+                                });
+                            return undefined;
+                        });
+                    }
+                    this.project(input.runId, event);
                 }
-                this.project(input.runId, event);
-            }
-            const result = await handle.result();
+            };
+            const [eventsResult, executionResult] = await Promise.allSettled([
+                consumeEvents(),
+                (async () => handle.result())()
+            ]);
+            if (eventsResult.status === 'rejected')
+                throw eventsResult.reason;
+            if (executionResult.status === 'rejected')
+                throw executionResult.reason;
+            const result = executionResult.value;
             const title = await titleTask;
             if (title && !titleController.signal.aborted)
                 await runtime.agent
@@ -473,30 +485,33 @@ export class MarAgentManagedRunController {
                         ? 'CANCELLED'
                         : 'FAILED';
             use?.terminal();
-            terminalPublished = true;
-            this.host.emit(input.runId, status === 'SUCCEEDED'
-                ? 'run.completed'
-                : status === 'CANCELLED'
-                    ? 'run.cancelled'
-                    : status === 'FAILED'
-                        ? 'run.failed'
-                        : 'run.completed', {
-                status,
-                ...(result.errorCode ? { code: result.errorCode } : {}),
-                ...(result.errorMessage ? { message: result.errorMessage } : {}),
-                ...(permissionStop === undefined
-                    ? {}
-                    : {
-                        permissionStop,
-                        code: permissionStop.action === 'ask'
-                            ? 'MAR_AGENT_PERMISSION_ASK'
-                            : 'MAR_AGENT_PERMISSION_DENIED',
-                        message: permissionStop.reason
-                    })
-            }, status);
+            terminalEvent = {
+                eventType: status === 'SUCCEEDED'
+                    ? 'run.completed'
+                    : status === 'CANCELLED'
+                        ? 'run.cancelled'
+                        : status === 'FAILED'
+                            ? 'run.failed'
+                            : 'run.completed',
+                payload: {
+                    status,
+                    ...(result.errorCode ? { code: result.errorCode } : {}),
+                    ...(result.errorMessage ? { message: result.errorMessage } : {}),
+                    ...(permissionStop === undefined
+                        ? {}
+                        : {
+                            permissionStop,
+                            code: permissionStop.action === 'ask'
+                                ? 'MAR_AGENT_PERMISSION_ASK'
+                                : 'MAR_AGENT_PERMISSION_DENIED',
+                            message: permissionStop.reason
+                        })
+                },
+                status
+            };
         }
         catch (error) {
-            if (terminalPublished) {
+            if (terminalEvent !== undefined) {
                 nodeLog('runner.mar-agent.run.cleanup_failed', {
                     runId: input.runId,
                     code: 'MAR_AGENT_RUN_CLEANUP_FAILED'
@@ -519,7 +534,7 @@ export class MarAgentManagedRunController {
                         retryAfterMs: null
                     }
                 });
-                this.host.emit(input.runId, 'run.failed', projected, 'FAILED');
+                terminalEvent = { eventType: 'run.failed', payload: projected, status: 'FAILED' };
             }
         }
         finally {
@@ -560,13 +575,22 @@ export class MarAgentManagedRunController {
             finally {
                 use?.terminal();
                 this.#normalizers.delete(input.runId);
-                this.host.active.delete(input.runId);
                 this.#executions.delete(input.runId);
                 this.#steerTargets.delete(input.runId);
-                resolveSettled();
+                if (cancelledDuringPreparation)
+                    terminalEvent = {
+                        eventType: 'run.cancelled',
+                        payload: { status: 'CANCELLED' },
+                        status: 'CANCELLED'
+                    };
+                try {
+                    if (terminalEvent !== undefined)
+                        this.host.emit(input.runId, terminalEvent.eventType, terminalEvent.payload, terminalEvent.status);
+                }
+                finally {
+                    resolveSettled();
+                }
             }
-            if (cancelledDuringPreparation)
-                this.host.emit(input.runId, 'run.cancelled', { status: 'CANCELLED' }, 'CANCELLED');
         }
     }
     #resolveMcpServers(installations, environment, executionServers = []) {

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -68,9 +68,6 @@ export class MarAgentRuntimeModelFactory {
                     ...(configuration.serviceTier === undefined
                         ? {}
                         : { serviceTier: configuration.serviceTier }),
-                    ...(configuration.serviceTier === undefined && configuration.fastMode === true
-                        ? { fastMode: true }
-                        : {}),
                     hostedWebSearch: configuration.hostedWebSearch,
                     useResourceUrl: configuration.useResourceUrl,
                     ...(imageGeneration === undefined ? {} : { imageGeneration }),

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

@@ -1,6 +1,6 @@
 import { marAgentNodeModelSummarySchema, parseComposerTags, resolveMarAgentDefaultReasoningEffort, serializeComposerTag } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
-import { runnerErrorProjection } from '../util/runner-error.js';
+import { runnerErrorProjection } from './runner-error.js';
 import { AgentError, openAgentSessionCatalog } from '@myagentroam/agent';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';

package/dist/runner/normalization.js

@@ -0,0 +1,42 @@
+export function compactRunnerText(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
+}
+export function compactRunnerValue(value, limit) {
+    if (value === undefined || value === null)
+        return { text: '', truncated: false };
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value);
+        }
+        catch {
+            return { text: '(Unable to display)', truncated: false };
+        }
+    }
+    return { text: compactRunnerText(text, limit), truncated: text.length > limit };
+}
+export function nativePageEnd(cursor, sessionId, fallback) {
+    if (cursor === undefined)
+        return fallback;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        return value.sessionId === sessionId &&
+            Number.isInteger(value.end) &&
+            value.end >= 0
+            ? Math.min(value.end, fallback)
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function boundedConversationItemId(prefix, value) {
+    const candidate = `${prefix}:${value}`;
+    if (candidate.length <= 88)
+        return candidate;
+    return `${prefix}:${Buffer.from(value)
+        .toString('base64url')
+        .slice(0, 88 - prefix.length - 1)}`;
+}

package/dist/runner/opencode/conversation-parser.js

@@ -1,4 +1,4 @@
-import { boundedConversationItemId, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
 import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';

package/dist/runner/opencode/managed-run-controller.js

@@ -1,9 +1,9 @@
 import { OpenCodeUsageNormalizer, openCodeSourceItemId } from './conversation-parser.js';
 import { parseComposerTags } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { parseSecretEnvironment } from '../../util/secret-environment.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
-import { boundedConversationItemId, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
+import { runnerErrorProjection } from '../runner-error.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
 import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
@@ -65,7 +65,7 @@ export class OpenCodeManagedRunController {
             externalSessionId: session.externalSessionId,
             ...(initiatedByUserId === undefined ? {} : { initiatedByUserId })
         });
-        this.host.active.add(runId);
+        this.host.executionAccepted(runId);
         this.runner.execution.set(runId, {
             runId,
             sessionId: session.id,
@@ -108,7 +108,7 @@ export class OpenCodeManagedRunController {
             typeof payload.cwd !== 'string' ||
             typeof payload.model !== 'string' ||
             this.host.intercepted() ||
-            this.host.active.has(payload.runId))
+            this.host.isExecutionActive(payload.runId))
             return;
         let environment;
         let mcp;
@@ -207,7 +207,7 @@ export class OpenCodeManagedRunController {
         const client = this.runner.managedClient(input.environment, hasMcpConfiguration(input.mcp) ? input.runId : undefined);
         this.startingClients.set(input.runId, client);
         this.startingCwds.set(input.runId, input.cwd);
-        this.host.active.add(input.runId);
+        this.host.executionAccepted(input.runId);
         this.host.emit(input.runId, 'run.started', {}, 'STARTING');
         let settlePrompt;
         const promptSettled = new Promise((resolve) => {
@@ -758,7 +758,6 @@ export class OpenCodeManagedRunController {
         this.messageParents.delete(runId);
         this.compactionPartIds.delete(runId);
         this.completedCompactionParents.delete(runId);
-        this.host.active.delete(runId);
         for (const [id, pending] of this.permissions)
             if (pending.runId === runId) {
                 clearTimeout(pending.timer);

package/dist/{opencode-server.js → runner/opencode/opencode-server.js}

@@ -1,8 +1,8 @@
 import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:net';
-import { minimalRunnerEnvironment, platformCliInvocation } from './operational.js';
-import { terminateProcessTree } from './process-tree.js';
+import { minimalRunnerEnvironment, platformCliInvocation } from '../../operational.js';
+import { terminateProcessTree } from '../../process-tree.js';
 const START_TIMEOUT_MS = 10_000;
 export class OpenCodeServerClient {
     options;

package/dist/runner/opencode/tool-normalizer.js

@@ -1,4 +1,4 @@
-import { compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../normalization.js';
 export function normalizeOpenCodeTool(toolName, state) {
     const status = state?.status === 'completed'
         ? 'COMPLETED'

package/dist/runner/opencode-runner.js

@@ -1,14 +1,14 @@
 import { withMarctlGuide } from '../mcp/marctl-guide.js';
-import { OpenCodeServerClient } from '../opencode-server.js';
+import { OpenCodeServerClient } from './opencode/opencode-server.js';
 import { openCodeContextLimits, openCodeProfileModels } from '../opencode-runtime.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { AbstractRunner } from './abstract-runner.js';
-import { isWithinWorkspace } from '../util/runner-native-session-parsers.js';
+import { isWithinWorkspace } from '../session/runner-native-session-parsers.js';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { openCodeConversationPage, openCodeUserMessagePreview } from './opencode/conversation-parser.js';
 import { nodeLog } from '../operational.js';
-import { runnerErrorProjection } from '../util/runner-error.js';
+import { runnerErrorProjection } from './runner-error.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
 const PROFILE_FAILURE_RETRY_MS = 30_000;
 const PROFILE_REFRESH_TIMEOUT_MS = 90_000;
@@ -355,10 +355,9 @@ export class OpenCodeRunner extends AbstractRunner {
             commandStates: context.commandStates
         };
     }
-    async renameNative(session, input, database) {
+    async renameNative(session, input) {
         if (session.externalSessionId !== null && input.title !== undefined)
             await this.client.updateSession(session.cwd, session.externalSessionId, input.title ?? '');
-        await super.renameNative(session, input, database);
     }
     async removeNative(session, nativeSessionId) {
         await this.client.deleteSession(session.cwd, nativeSessionId);

package/dist/runner/runner-registry.js

@@ -94,6 +94,9 @@ export class RunnerRegistry {
         return false;
     }
     async stop() {
-        await Promise.allSettled([...this.runners.values()].map((runner) => runner.stop()));
+        const results = await Promise.allSettled([...this.runners.values()].map(async (runner) => runner.stop()));
+        const failure = results.find((result) => result.status === 'rejected');
+        if (failure !== undefined)
+            throw failure.reason;
     }
 }