@myagentroam/node 0.10.61 → 0.10.63

package/dist/runner/mar-agent/session-runtime-registry.js

@@ -0,0 +1,271 @@
+import { closeImageCredentialProviders } from './runtime-model-factory.js';
+import { nodeLog } from '../../operational.js';
+import { createSessionRuntime, reconfigureSessionRuntime, releaseSessionRuntime, resolveMarAgentHostRuntimeConfiguration, sessionHostFingerprint, HOST_CONFIGURATION_CATEGORIES } from './session-runtime.js';
+export class MarAgentSessionRuntimeRegistry {
+    resources;
+    promote;
+    releaseComputerSession;
+    #entries = new Map();
+    #disposed = false;
+    #disposePromise;
+    constructor(resources, promote, releaseComputerSession) {
+        this.resources = resources;
+        this.promote = promote;
+        this.releaseComputerSession = releaseComputerSession;
+    }
+    findRuntime(alias) {
+        const entry = this.#entries.get(alias);
+        return entry?.release === undefined ? entry?.runtime : undefined;
+    }
+    acquire(input, lifetime) {
+        if (this.#disposed)
+            return Promise.reject(new Error('MAR_AGENT_RUN_CONTROLLER_DISPOSED'));
+        const aliases = new Set([input.sessionId, input.externalSessionId ?? input.sessionId]);
+        const entries = new Set([...aliases].flatMap((alias) => {
+            const entry = this.#entries.get(alias);
+            return entry === undefined ? [] : [entry];
+        }));
+        if (entries.size > 1)
+            return Promise.reject(new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE'));
+        const entry = entries.values().next().value ?? {
+            aliases: new Set(),
+            users: new Set()
+        };
+        if (entry.release !== undefined) {
+            const release = entry.release;
+            if (release.reason !== 'idle_expired')
+                return Promise.reject(new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED'));
+            return release.result.then(() => {
+                if (release.reason !== 'idle_expired')
+                    throw new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED');
+                return this.acquire(input, lifetime);
+            });
+        }
+        if (entry.current !== undefined || entry.acquisition !== undefined)
+            return Promise.reject(new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE'));
+        for (const alias of aliases)
+            this.#addAlias(entry, alias);
+        this.#clearTimer(entry);
+        entry.current = lifetime;
+        entry.users.add(lifetime);
+        void lifetime.settled.then(() => entry.users.delete(lifetime));
+        // Publish the acquisition before any dependency can synchronously reenter.
+        const acquisition = Promise.resolve().then(async () => {
+            let uncommitted;
+            try {
+                this.#assertUsable(entry, lifetime);
+                const configuration = await resolveMarAgentHostRuntimeConfiguration(input.secretEnvironment);
+                this.#assertUsable(entry, lifetime);
+                const fingerprint = sessionHostFingerprint(input, configuration);
+                const existing = entry.runtime;
+                if (existing !== undefined && existing.fingerprint.value === fingerprint.value) {
+                    await reconfigureSessionRuntime(existing, input, this.resources.modelFactory);
+                    this.#assertUsable(entry, lifetime);
+                    nodeLog('runner.mar-agent.runtime.reused', {
+                        runtimeId: existing.runtimeId,
+                        sessionId: existing.session.id,
+                        runId: input.runId
+                    });
+                }
+                else {
+                    let nativeId = input.externalSessionId;
+                    if (existing !== undefined) {
+                        nativeId = existing.session.id;
+                        await Promise.all([...entry.users].filter((user) => user !== lifetime).map((user) => user.settled));
+                        this.#assertUsable(entry, lifetime);
+                        delete entry.runtime;
+                        await this.#destroyRuntime(existing, entry.aliases, 'host_configuration_changed', undefined, HOST_CONFIGURATION_CATEGORIES.filter((category) => existing.fingerprint.categories[category] !== fingerprint.categories[category]));
+                        this.#assertUsable(entry, lifetime);
+                    }
+                    const request = nativeId === undefined ? input : { ...input, externalSessionId: nativeId };
+                    let created;
+                    created = await createSessionRuntime(request, nativeId ?? input.sessionId, fingerprint, configuration, this.resources, () => created !== undefined && entry.runtime === created && entry.release === undefined
+                        ? entry.current?.runId
+                        : undefined);
+                    uncommitted = created;
+                    this.#addAlias(entry, uncommitted.session.id);
+                    nodeLog('runner.mar-agent.runtime.created', {
+                        runtimeId: uncommitted.runtimeId,
+                        sessionId: uncommitted.session.id,
+                        runId: input.runId
+                    });
+                    if (input.externalSessionId === undefined)
+                        this.promote(input.sessionId, uncommitted.session.id);
+                    this.#assertUsable(entry, lifetime);
+                    entry.runtime = uncommitted;
+                    uncommitted = undefined;
+                }
+                const runtime = entry.runtime;
+                return {
+                    runtime,
+                    assertUsable: () => this.#assertUsable(entry, lifetime),
+                    terminal: () => this.#terminal(entry, lifetime)
+                };
+            }
+            catch (error) {
+                if (uncommitted !== undefined) {
+                    nodeLog('runner.mar-agent.runtime.releasing', {
+                        runtimeId: uncommitted.runtimeId,
+                        sessionId: uncommitted.session.id,
+                        reason: 'admission_released',
+                        runId: input.runId
+                    });
+                    // No Execution was bound: do not release another Entry's Session resources
+                    // if alias registration failed because the SDK returned an existing identity.
+                    try {
+                        await releaseSessionRuntime(uncommitted);
+                    }
+                    catch {
+                        this.#logCleanupFailure(uncommitted.session.id);
+                    }
+                    finally {
+                        await closeImageCredentialProviders(uncommitted.models);
+                    }
+                }
+                entry.users.delete(lifetime);
+                if (entry.current === lifetime)
+                    delete entry.current;
+                throw error;
+            }
+            finally {
+                delete entry.acquisition;
+                if (entry.release === undefined && entry.current === undefined) {
+                    if (entry.runtime === undefined)
+                        this.#remove(entry);
+                    else
+                        this.#schedule(entry);
+                }
+            }
+        });
+        entry.acquisition = acquisition;
+        return acquisition;
+    }
+    releaseSession(alias) {
+        const existing = this.#entries.get(alias);
+        if (existing?.release !== undefined) {
+            existing.release.reason = 'session_released';
+            return existing.release.result;
+        }
+        if (this.#disposed)
+            return this.#disposePromise;
+        const entry = existing ?? { aliases: new Set([alias]), users: new Set() };
+        if (existing === undefined)
+            this.#entries.set(alias, entry);
+        return this.#release(entry, 'session_released');
+    }
+    dispose() {
+        if (this.#disposePromise !== undefined)
+            return this.#disposePromise;
+        this.#disposed = true;
+        this.#disposePromise = Promise.resolve().then(async () => {
+            const results = await Promise.allSettled([...new Set(this.#entries.values())].map((entry) => this.#release(entry, 'controller_disposed')));
+            const failure = results.find((result) => result.status === 'rejected');
+            if (failure?.status === 'rejected')
+                throw failure.reason;
+        });
+        return this.#disposePromise;
+    }
+    #assertUsable(entry, lifetime) {
+        lifetime.signal.throwIfAborted();
+        if (this.#disposed)
+            throw new Error('MAR_AGENT_RUN_CONTROLLER_DISPOSED');
+        if (entry.release !== undefined || entry.current !== lifetime)
+            throw new Error('MAR_AGENT_SESSION_RUNTIME_RELEASED');
+    }
+    #addAlias(entry, alias) {
+        const existing = this.#entries.get(alias);
+        if (existing !== undefined && existing !== entry)
+            throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
+        entry.aliases.add(alias);
+        this.#entries.set(alias, entry);
+    }
+    #terminal(entry, lifetime) {
+        if (entry.current !== lifetime)
+            return;
+        delete entry.current;
+        this.#schedule(entry);
+    }
+    #clearTimer(entry) {
+        if (entry.idleTimer === undefined)
+            return;
+        clearTimeout(entry.idleTimer);
+        delete entry.idleTimer;
+    }
+    #schedule(entry) {
+        if (entry.runtime === undefined ||
+            entry.current !== undefined ||
+            entry.acquisition !== undefined ||
+            entry.release !== undefined ||
+            entry.idleTimer !== undefined ||
+            this.#disposed)
+            return;
+        const timer = setTimeout(() => {
+            if (entry.idleTimer !== timer || entry.current !== undefined || entry.release !== undefined)
+                return;
+            const sessionId = entry.runtime?.session.id;
+            void this.#release(entry, 'idle_expired').catch(() => this.#logCleanupFailure(sessionId));
+        }, this.resources.resourceIdleTtlMs);
+        entry.idleTimer = timer;
+        timer.unref();
+    }
+    #release(entry, reason) {
+        if (entry.release !== undefined)
+            return entry.release.result;
+        this.#clearTimer(entry);
+        const runId = entry.current?.runId;
+        const result = Promise.resolve().then(async () => {
+            try {
+                for (const user of entry.users)
+                    user.cancel();
+                await entry.acquisition?.catch(() => undefined);
+                await Promise.all([...entry.users].map((user) => user.settled));
+                const runtime = entry.runtime;
+                delete entry.runtime;
+                if (runtime !== undefined)
+                    await this.#destroyRuntime(runtime, entry.aliases, reason, runId);
+                else
+                    await this.#releaseComputerAliases(entry.aliases);
+            }
+            finally {
+                this.#remove(entry);
+            }
+        });
+        entry.release = { reason, result };
+        return result;
+    }
+    async #releaseComputerAliases(aliases) {
+        const results = await Promise.allSettled([...aliases].map((alias) => this.releaseComputerSession(alias)));
+        const failure = results.find((result) => result.status === 'rejected');
+        if (failure?.status === 'rejected')
+            throw failure.reason;
+    }
+    async #destroyRuntime(runtime, aliases, reason, runId, changedCategories = []) {
+        nodeLog('runner.mar-agent.runtime.releasing', {
+            runtimeId: runtime.runtimeId,
+            sessionId: runtime.session.id,
+            reason,
+            ...(runId === undefined ? {} : { runId }),
+            ...(changedCategories.length === 0 ? {} : { changedCategories })
+        });
+        const results = await Promise.allSettled([
+            this.#releaseComputerAliases(new Set([...aliases, runtime.session.id]))
+        ]);
+        results.push(...(await Promise.allSettled([releaseSessionRuntime(runtime)])));
+        const failures = results.filter((result) => result.status === 'rejected');
+        if (failures.length > 1)
+            this.#logCleanupFailure(runtime.session.id);
+        if (failures[0]?.status === 'rejected')
+            throw failures[0].reason;
+    }
+    #remove(entry) {
+        for (const alias of entry.aliases)
+            if (this.#entries.get(alias) === entry)
+                this.#entries.delete(alias);
+    }
+    #logCleanupFailure(sessionId) {
+        nodeLog('runner.mar-agent.runtime.cleanup_failed', {
+            sessionId,
+            code: 'MAR_AGENT_RUNTIME_CLEANUP_FAILED'
+        });
+    }
+}

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

@@ -0,0 +1,282 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { access, constants } from 'node:fs/promises';
+import { LocalAgentHost } from '@myagentroam/agent';
+import { marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
+import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
+import { nodeLog } from '../../operational.js';
+import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
+import { canonicalJson } from '../../util/canonical-json.js';
+import { compactRuntimeConfigurations, marAgentCompactExtensionSource, updateMarAgentCompactState } from './compact-extensions.js';
+import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
+import { sdkModelConfigurations } from './runtime-model-factory.js';
+export const HOST_CONFIGURATION_CATEGORIES = [
+    'cwd',
+    'mcpServers',
+    'environment',
+    'guaranteedCommands'
+];
+export async function createSessionRuntime(input, sessionKey, fingerprint, hostConfiguration, dependencies, currentRunId) {
+    const sharedMcpServers = input.mcpServers.filter((server) => !isExecutionScopedMcp(server));
+    const mcpLease = await dependencies.mcpClients.acquire(sharedMcpServers, input.cwd, {
+        // Native Session IDs are assigned after the first lease; do not let that promotion
+        // change a confirmed actor's discovery identity when its warm runtime is recreated.
+        authorizationScope: input.secretEnvironment?.['MAR_USERNAME'] ? input.cwd : sessionKey
+    });
+    let agent;
+    let models = [];
+    let releaseEnvironment;
+    try {
+        releaseEnvironment = dependencies.retainEnvironment?.(input.secretEnvironment ?? {});
+        const mcp = mcpLease.pool;
+        const localHost = new LocalAgentHost({
+            modelUsage: (usage) => {
+                const runId = currentRunId();
+                if (runId !== undefined)
+                    dependencies.modelUsage(runId, usage);
+            },
+            mode: 'node',
+            homeDirectory: homedir(),
+            workspace: input.cwd,
+            environment: hostConfiguration.environment,
+            guaranteedCommands: hostConfiguration.guaranteedCommands,
+            question: async (request, signal) => {
+                const runId = currentRunId();
+                return runId === undefined ? {} : dependencies.question(runId, request, signal);
+            },
+            approval: dependencies.approval
+                ? (request, signal) => {
+                    const runId = currentRunId();
+                    if (runId === undefined)
+                        return Promise.resolve('REJECTED');
+                    return dependencies.approval(runId, request, signal);
+                }
+                : undefined,
+            mcpCatalog: () => mcp.catalog(),
+            callMcp: async (call, signal, context) => mcp.call(call.name, call.arguments, signal, context?.expectedTool),
+            resourceIdleTtlMs: dependencies.resourceIdleTtlMs
+        });
+        models = dependencies.modelFactory.create(compactRuntimeConfigurations(input.models, input.compact), {
+            ...(input.runtimeScopeId === undefined ? {} : { runtimeScopeId: input.runtimeScopeId }),
+            executionId: input.runId
+        });
+        const compactState = { revision: 0 };
+        updateMarAgentCompactState(compactState, input.compact, models, input.models.map((model) => model.id));
+        agent = await dependencies.createAgent({
+            mode: 'node',
+            host: localHost,
+            models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
+            defaultModelId: input.model.id,
+            runtimeExtensions: marAgentCompactExtensionSource(compactState),
+            ...(input.personalInstructions ? { systemInstruction: input.personalInstructions } : {})
+        });
+        const customTitle = dependencies.customTitle(input.sessionId) ?? undefined;
+        const session = input.externalSessionId
+            ? await agent.openSession(input.externalSessionId)
+            : await agent.createSession({
+                workspace: input.cwd,
+                ...(customTitle === undefined ? {} : { title: customTitle })
+            });
+        const runtime = {
+            runtimeId: randomUUID(),
+            fingerprint,
+            agent,
+            session,
+            host: localHost,
+            normalizer: new MarAgentConversationNormalizer(),
+            mcpLease,
+            releaseEnvironment,
+            automaticTitleEnabled: input.externalSessionId === undefined,
+            models,
+            compactState,
+            modelFingerprint: sessionModelFingerprint(input),
+            personalInstructions: input.personalInstructions ?? ''
+        };
+        return runtime;
+    }
+    catch (error) {
+        for (const cleanup of [
+            () => agent?.dispose(),
+            () => closeModelCredentialProviders(models),
+            () => mcpLease.release(),
+            () => releaseEnvironment?.()
+        ]) {
+            try {
+                await cleanup();
+            }
+            catch {
+                nodeLog('runner.mar-agent.runtime.cleanup_failed', {
+                    sessionId: sessionKey,
+                    code: 'MAR_AGENT_RUNTIME_CLEANUP_FAILED',
+                    stage: 'creation_rollback'
+                });
+            }
+        }
+        throw error;
+    }
+}
+export async function reconfigureSessionRuntime(existing, input, modelFactory) {
+    const modelFingerprint = sessionModelFingerprint(input);
+    const configurations = compactRuntimeConfigurations(input.models, input.compact);
+    if (existing.modelFingerprint !== modelFingerprint ||
+        configurations.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
+            model.imageGeneration?.credential?.type === 'RUNTIME_TICKET')) {
+        const models = modelFactory.create(configurations, {
+            ...(input.runtimeScopeId === undefined ? {} : { runtimeScopeId: input.runtimeScopeId }),
+            executionId: input.runId
+        });
+        try {
+            await existing.agent.reconfigureModels({
+                models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
+                defaultModelId: input.model.id
+            });
+            existing.models = models;
+            existing.modelFingerprint = modelFingerprint;
+        }
+        catch (error) {
+            await closeModelCredentialProviders(models);
+            throw error;
+        }
+    }
+    const personalInstructions = input.personalInstructions ?? (input.mode === 'compact' ? existing.personalInstructions : '');
+    if (existing.personalInstructions !== personalInstructions) {
+        existing.agent.setSystemInstruction(personalInstructions || undefined);
+        existing.personalInstructions = personalInstructions;
+    }
+    updateMarAgentCompactState(existing.compactState, input.compact, existing.models, input.models.map((model) => model.id));
+}
+export async function releaseSessionRuntime(runtime) {
+    const failures = [];
+    for (const cleanup of [
+        () => runtime.agent.dispose(),
+        () => runtime.mcpLease.release(),
+        () => runtime.releaseEnvironment?.()
+    ]) {
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length > 1)
+        nodeLog('runner.mar-agent.runtime.cleanup_failed', {
+            sessionId: runtime.session.id,
+            code: 'MAR_AGENT_RUNTIME_CLEANUP_FAILED',
+            stage: 'resource_release'
+        });
+    if (failures.length > 0)
+        throw failures[0];
+}
+export function isExecutionScopedMcp(server) {
+    return (server.lifecycle === 'EXECUTION' ||
+        (server.transport === 'STDIO' && server.environment?.['MAR_CTL_USER_TOKEN'] !== undefined));
+}
+export function sessionHostFingerprint(input, hostConfiguration) {
+    const configuration = {
+        cwd: input.cwd,
+        mcpServers: input.mcpServers.filter((server) => !isExecutionScopedMcp(server)),
+        environment: Object.entries(hostConfiguration.environment)
+            .filter((entry) => entry[1] !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right)),
+        guaranteedCommands: Object.entries(hostConfiguration.guaranteedCommands).sort(([left], [right]) => left.localeCompare(right))
+    };
+    const digest = (value) => createHash('sha256').update(canonicalJson(value)).digest('hex');
+    return {
+        value: digest(configuration),
+        // Only fixed category names leave this comparison; never log these value fingerprints.
+        categories: {
+            cwd: digest(configuration.cwd),
+            mcpServers: digest(configuration.mcpServers),
+            environment: digest(configuration.environment),
+            guaranteedCommands: digest(configuration.guaranteedCommands)
+        }
+    };
+}
+function sessionModelFingerprint(input) {
+    const compact = marAgentRuntimeCompactConfigurationSchema.safeParse(input.compact);
+    return createHash('sha256')
+        .update(JSON.stringify({
+        defaultModelId: input.model.id,
+        compact: compact.success
+            ? {
+                model: runtimeModelFingerprint(compact.data.model),
+                effort: compact.data.reasoningEffort
+            }
+            : null,
+        models: input.models.map(runtimeModelFingerprint)
+    }))
+        .digest('hex');
+}
+export async function resolveMarAgentHostRuntimeConfiguration(secretEnvironment = {}) {
+    const environment = nodeExecutionEnvironment({
+        ...secretEnvironment,
+        MAR_CTL_CONTEXT_REQUIRED: '1'
+    });
+    // CLI credentials are bound to each execution, never retained as Host configuration.
+    delete environment['MAR_CTL_USER_TOKEN'];
+    for (const key of [
+        'MAR_CTL_NODE_ID',
+        'MAR_CTL_WORKSPACE_ID',
+        'MAR_CTL_SESSION_ID',
+        'MAR_CTL_RUN_ID',
+        'MAR_CTL_RUNNER'
+    ])
+        delete environment[key];
+    const ripgrep = await availableBundledRipgrep();
+    return {
+        environment: ripgrep === undefined ? environment : prependBundledRipgrepToPath(environment, ripgrep),
+        guaranteedCommands: ripgrep === undefined ? {} : { rg: BUNDLED_RIPGREP_VERSION }
+    };
+}
+async function availableBundledRipgrep() {
+    try {
+        const executable = bundledRipgrepPath();
+        await access(executable, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return executable;
+    }
+    catch {
+        return undefined;
+    }
+}
+function runtimeModelFingerprint(model) {
+    const { apiKey, credential, imageGeneration, ...configuration } = model;
+    return {
+        ...configuration,
+        ...(imageGeneration === undefined
+            ? {}
+            : {
+                imageGeneration: {
+                    ...imageGeneration,
+                    credential: runtimeCredentialFingerprint(imageGeneration.credential)
+                }
+            }),
+        ...(apiKey === undefined
+            ? {}
+            : { apiKeyHash: createHash('sha256').update(apiKey).digest('hex') }),
+        credential: runtimeCredentialFingerprint(credential)
+    };
+}
+function runtimeCredentialFingerprint(credential) {
+    return credential?.type === 'INLINE_API_KEY'
+        ? {
+            type: credential.type,
+            valueHash: createHash('sha256').update(credential.value).digest('hex')
+        }
+        : credential === undefined
+            ? undefined
+            : {
+                type: credential.type,
+                credentialId: credential.credentialId
+            };
+}
+async function closeModelCredentialProviders(models) {
+    await Promise.allSettled([
+        ...new Set(models.flatMap((model) => [
+            ...(model.credentialProvider === undefined ? [] : [model.credentialProvider]),
+            ...(model.imageGeneration?.credentialProvider === undefined
+                ? []
+                : [model.imageGeneration.credentialProvider])
+        ]))
+    ].map((provider) => provider.close()));
+}