@myagentroam/agent 0.9.141 → 0.9.143

package/dist/agent-core/runtime/execution.js

@@ -0,0 +1,397 @@
+import { MarAgentError } from '../error.js';
+import { isProviderContextOverflow, recoverModelStream } from '../model/recovery.js';
+import { modelStreamEventObservedAt } from '../model/sse.js';
+import { modelOutputContinuationMessage } from '../prompts/output.js';
+import { executeRoundTools } from '../tools/execution.js';
+import { publicModelUsage } from './event-projection.js';
+import { PlanOutputPrefix, splitPlanOutput } from './plan-output.js';
+/** Own the single model/tool loop; the SDK owns its handle, terminal events and cleanup. */
+export class ExecutionLoop {
+    input;
+    #finalAnswer = '';
+    planOutputPrefixes = new Map();
+    get finalAnswer() {
+        return this.#finalAnswer;
+    }
+    set finalAnswer(value) {
+        this.#finalAnswer = value;
+    }
+    constructor(input) {
+        this.input = input;
+    }
+    async run() {
+        const input = this.input;
+        const { mode, messages } = input;
+        let recoveringFromContextOverflow = false;
+        let maxOutputContinuationUsed = false;
+        let pendingOutputContinuation;
+        const modelRetryState = { attempts: 0 };
+        while (true) {
+            let stop;
+            let sawTool = false;
+            let latestUsage;
+            let roundServerUsage;
+            const pendingTools = [];
+            let incompleteToolCall = false;
+            const round = await input.prepareRound(pendingOutputContinuation);
+            let sawModelSemanticEvent = false;
+            let requestStartedAt;
+            let firstModelResponseAt;
+            let firstOutputDeltaAt;
+            let lastOutputDeltaAt;
+            let requestCompletedAt;
+            let requestOutputTokens;
+            const roundMessageCount = messages.length;
+            const emitLatency = async () => {
+                if (mode === 'compact' || firstModelResponseAt === undefined)
+                    return;
+                await input.publish({
+                    type: 'model.performance',
+                    latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt))
+                });
+            };
+            const emitFinalPerformance = async (completedAt) => {
+                if (mode === 'compact' ||
+                    firstModelResponseAt === undefined ||
+                    firstOutputDeltaAt === undefined ||
+                    lastOutputDeltaAt === undefined ||
+                    lastOutputDeltaAt - firstOutputDeltaAt < 1)
+                    return;
+                const outputDuration = completedAt - firstOutputDeltaAt;
+                const outputTokens = requestOutputTokens;
+                if (outputTokens === undefined || outputDuration < 1 || completedAt < lastOutputDeltaAt)
+                    return;
+                await input.publish({
+                    type: 'model.performance',
+                    latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
+                    outputTokens,
+                    outputDurationMs: Math.round(outputDuration),
+                    tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
+                });
+            };
+            const persistToolCalls = async (calls) => {
+                for (const call of calls) {
+                    const message = {
+                        role: 'tool_call',
+                        callId: call.callId,
+                        name: call.name,
+                        arguments: call.arguments,
+                        ...(call.inputMode ? { inputMode: call.inputMode } : {}),
+                        content: ''
+                    };
+                    messages.push(message);
+                    await input.appendContext(message);
+                }
+            };
+            try {
+                requestStartedAt = performance.now();
+                for await (const event of input.startModel({
+                    ...round.request,
+                    retryState: modelRetryState
+                })) {
+                    if (event.type === 'output.reset') {
+                        firstOutputDeltaAt = undefined;
+                        lastOutputDeltaAt = undefined;
+                        requestOutputTokens = undefined;
+                        continue;
+                    }
+                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
+                        ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
+                        : undefined;
+                    const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
+                    if (modelResponseAt !== undefined) {
+                        if (event.type !== 'output.delta')
+                            sawModelSemanticEvent = true;
+                        firstModelResponseAt ??= modelResponseAt;
+                        if (event.type === 'output.delta' ||
+                            (event.type === 'text.delta' && event.delta.length > 0)) {
+                            firstOutputDeltaAt ??= modelResponseAt;
+                            lastOutputDeltaAt = modelResponseAt;
+                        }
+                    }
+                    if (event.type === 'response.item') {
+                        // Compaction keeps only its successful checkpoint, never intermediate native output.
+                        if (mode === 'compact')
+                            continue;
+                        const message = {
+                            role: 'provider',
+                            content: '',
+                            provider: event.provider,
+                            providerModelId: input.model.id,
+                            ...(event.provider === 'ANTHROPIC_MESSAGES'
+                                ? { contextKind: 'private' }
+                                : {}),
+                            item: event.item
+                        };
+                        messages.push(message);
+                        await input.appendContext(message);
+                    }
+                    else if (event.type === 'text.delta') {
+                        let delta = event.delta;
+                        if (mode === 'plan' && input.sourceType !== 'subagent') {
+                            let prefix = this.planOutputPrefixes.get(event.itemId);
+                            if (!prefix) {
+                                prefix = new PlanOutputPrefix();
+                                this.planOutputPrefixes.set(event.itemId, prefix);
+                            }
+                            delta = prefix.push(delta);
+                        }
+                        if (mode !== 'compact' && delta) {
+                            await input.publish({
+                                type: 'message.delta',
+                                itemId: event.itemId,
+                                phase: event.phase,
+                                delta
+                            });
+                        }
+                    }
+                    else if (event.type === 'text.completed') {
+                        const phase = event.phase ?? 'final_answer';
+                        if (phase === 'final_answer')
+                            this.finalAnswer = event.text;
+                        this.planOutputPrefixes.delete(event.itemId);
+                        if (mode !== 'compact') {
+                            if (mode === 'plan' && input.sourceType !== 'subagent') {
+                                const parts = splitPlanOutput(event.text);
+                                for (const [index, part] of parts.entries()) {
+                                    const itemId = index === 0 ? event.itemId : `${event.itemId}:plan-part:${index}`;
+                                    if (part.kind === 'plan')
+                                        await input.publish({ type: 'plan.completed', itemId, text: part.text });
+                                    else {
+                                        await input.publish({
+                                            type: 'message.completed',
+                                            itemId,
+                                            phase,
+                                            text: part.text,
+                                            modelId: input.model.id,
+                                            modelName: input.model.name
+                                        });
+                                    }
+                                }
+                            }
+                            else {
+                                await input.publish({
+                                    type: 'message.completed',
+                                    itemId: event.itemId,
+                                    phase,
+                                    text: event.text,
+                                    modelId: input.model.id,
+                                    modelName: input.model.name
+                                });
+                            }
+                        }
+                        messages.push({ role: 'assistant', content: event.text });
+                    }
+                    else if (event.type === 'usage') {
+                        latestUsage = event.usage;
+                        const outputTokens = typeof event.usage.outputTokens === 'number' &&
+                            Number.isSafeInteger(event.usage.outputTokens) &&
+                            event.usage.outputTokens >= 0
+                            ? event.usage.outputTokens
+                            : undefined;
+                        if (outputTokens !== undefined) {
+                            requestOutputTokens = outputTokens;
+                        }
+                        const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
+                        if (reportedContext !== undefined &&
+                            Number.isSafeInteger(reportedContext) &&
+                            reportedContext >= 0) {
+                            input.observeContextTokens(reportedContext);
+                            roundServerUsage = {
+                                contextInputTokens: reportedContext,
+                                outputTokens: typeof event.usage.outputTokens === 'number' &&
+                                    Number.isSafeInteger(event.usage.outputTokens) &&
+                                    event.usage.outputTokens >= 0
+                                    ? event.usage.outputTokens
+                                    : undefined
+                            };
+                        }
+                        await input.publish({ type: 'usage.updated', ...publicModelUsage(event.usage) });
+                    }
+                    else if (event.type === 'reasoning.summary') {
+                        if (mode !== 'compact')
+                            await input.publish({ type: 'reasoning.summary', text: event.text });
+                    }
+                    else if (event.type === 'hosted_tool') {
+                        if (mode !== 'compact')
+                            await input.publish({
+                                type: 'hosted_tool.updated',
+                                itemId: event.itemId,
+                                kind: event.kind,
+                                status: event.status,
+                                summary: event.summary
+                            });
+                    }
+                    else if (event.type === 'citation') {
+                        if (mode !== 'compact')
+                            await input.publish({
+                                type: 'citation.added',
+                                id: event.citation.id,
+                                url: event.citation.url,
+                                ...(event.citation.title ? { title: event.citation.title } : {})
+                            });
+                    }
+                    else if (event.type === 'client_tool.call') {
+                        if (mode === 'compact')
+                            throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
+                        sawTool = true;
+                        pendingTools.push(event);
+                    }
+                    else if (event.type === 'completed') {
+                        stop = event.reason;
+                        requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
+                    }
+                    if (isFirstModelResponse)
+                        await emitLatency();
+                }
+                if (mode !== 'compact' && firstModelResponseAt !== undefined) {
+                    const completedAt = requestCompletedAt ?? performance.now();
+                    await emitFinalPerformance(completedAt);
+                }
+                pendingOutputContinuation = undefined;
+                incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
+                if (!(stop === 'max_output' && incompleteToolCall)) {
+                    await persistToolCalls(pendingTools);
+                }
+                else
+                    pendingTools.splice(0, pendingTools.length);
+                modelRetryState.attempts = 0;
+            }
+            catch (error) {
+                this.planOutputPrefixes.clear();
+                if (await recoverModelStream(error, modelRetryState, input.recoverySignal())) {
+                    this.finalAnswer = '';
+                    if (mode === 'compact')
+                        messages.splice(roundMessageCount);
+                    if (pendingTools.some((call) => call.argumentError !== undefined))
+                        pendingTools.splice(0, pendingTools.length);
+                    else if (pendingTools.length > 0)
+                        await persistToolCalls(pendingTools);
+                    if (pendingTools.length === 0)
+                        continue;
+                }
+                else if (mode === 'compact' &&
+                    !sawModelSemanticEvent &&
+                    isProviderContextOverflow(error) &&
+                    input.compactionFallback?.()) {
+                    modelRetryState.attempts = 0;
+                    this.finalAnswer = '';
+                    continue;
+                }
+                else if (mode !== 'compact' &&
+                    !sawModelSemanticEvent &&
+                    isProviderContextOverflow(error)) {
+                    if (!recoveringFromContextOverflow && (await input.compactContext())) {
+                        modelRetryState.attempts = 0;
+                        recoveringFromContextOverflow = true;
+                        continue;
+                    }
+                    throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The model rejected the compacted context as too large.', { cause: error });
+                }
+                else
+                    throw error;
+            }
+            recoveringFromContextOverflow = false;
+            input.observeUsage(roundServerUsage);
+            if (pendingTools.length === 0 && input.mailbox.hasPending()) {
+                await input.mailbox.append();
+                this.finalAnswer = '';
+                continue;
+            }
+            const toolResults = await executeRoundTools(pendingTools, round.toolScope);
+            for (const result of toolResults) {
+                if ('images' in result && result.images?.length)
+                    input.toolImages.push(...result.images.map((image) => ({
+                        mimeType: image.mimeType,
+                        data: Buffer.from(image.dataBase64, 'base64')
+                    })));
+                const toolSearchTools = result.call.name === 'tool_search' && !result.failed
+                    ? result.output.toolSearchTools
+                    : undefined;
+                const message = {
+                    role: 'tool',
+                    callId: result.call.callId,
+                    content: result.content,
+                    ...(result.calls ? { calls: result.calls } : {}),
+                    ...(result.observations ? { observations: result.observations } : {}),
+                    ...(toolSearchTools === undefined ? {} : { toolSearchTools }),
+                    ...('images' in result && result.images?.length ? { images: result.images } : {})
+                };
+                messages.push(message);
+                await input.appendContext({
+                    role: message.role,
+                    callId: result.call.callId,
+                    content: message.content,
+                    ...(message.calls ? { calls: message.calls } : {}),
+                    ...(message.observations ? { observations: message.observations } : {}),
+                    ...(message.toolSearchTools === undefined
+                        ? {}
+                        : { toolSearchTools: message.toolSearchTools })
+                });
+            }
+            if (sawTool) {
+                modelRetryState.attempts = 0;
+                if (input.sourceType === 'subagent')
+                    this.finalAnswer = '';
+            }
+            input.rolloutBudget?.recordUsage(latestUsage);
+            if (mode !== 'compact' && stop === 'max_output') {
+                const needsContinuation = !sawTool || incompleteToolCall;
+                if (needsContinuation) {
+                    if (maxOutputContinuationUsed ||
+                        (input.rolloutBudget?.active && input.rolloutBudget.stage === 'exhausted'))
+                        throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
+                    maxOutputContinuationUsed = true;
+                    pendingOutputContinuation = {
+                        role: 'user',
+                        content: modelOutputContinuationMessage
+                    };
+                    this.finalAnswer = '';
+                    continue;
+                }
+                maxOutputContinuationUsed = false;
+            }
+            else
+                maxOutputContinuationUsed = false;
+            await input.checkpoint(round, latestUsage);
+            if (input.signal.aborted) {
+                const aborted = toolResults.find((result) => result.failed)?.error;
+                throw aborted ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.');
+            }
+            if (input.mailbox.hasPending()) {
+                await input.mailbox.append();
+                this.finalAnswer = '';
+                continue;
+            }
+            if (stop === 'completed' && !sawTool) {
+                input.mailbox.close();
+                const compactSummary = mode === 'compact' ? this.finalAnswer.trim() : '';
+                if (mode === 'compact' && !compactSummary)
+                    throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Compaction returned an empty handoff.');
+                if (mode !== 'compact' && !this.finalAnswer.trim())
+                    throw new MarAgentError(input.sourceType === 'subagent'
+                        ? 'MAR_AGENT_SUBAGENT_FAILED'
+                        : 'MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', input.sourceType === 'subagent'
+                        ? 'Subagent completed without a final summary.'
+                        : 'Model completed without an answer or tool request.');
+                return {
+                    finalAnswer: this.finalAnswer,
+                    ...(latestUsage === undefined ? {} : { usage: latestUsage })
+                };
+            }
+            if (!sawTool && stop !== 'pause')
+                throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model did not complete or request a tool.');
+        }
+    }
+}
+function isModelResponseEvent(event) {
+    if (event.type === 'text.delta')
+        return event.delta.length > 0;
+    if (event.type === 'text.completed' || event.type === 'reasoning.summary')
+        return event.text.length > 0;
+    return (event.type === 'response.item' ||
+        event.type === 'output.delta' ||
+        event.type === 'client_tool.call' ||
+        event.type === 'hosted_tool' ||
+        event.type === 'citation');
+}

package/dist/{runtime → agent-core/runtime}/rollout-budget.d.ts

@@ -1,5 +1,5 @@
 import type { ModelUsage } from '../model/contracts.js';
-import type { RolloutBudgetOptions } from '../sdk/types.js';
+import type { RolloutBudgetOptions } from './contracts.js';
 export type RolloutBudgetStage = 'normal' | 'conserve' | 'finalize' | 'exhausted';
 export interface ResolvedRolloutBudgetOptions {
     limitTokens: number;

package/dist/agent-core/sdk/agent.js

@@ -0,0 +1,209 @@
+import { addModelCredentialProviders, closeModelAdapters, resolveAgentModels } from './model-runtime.js';
+import { createSessionOpener } from './session.js';
+import { MarAgentError } from '../error.js';
+import { negotiateHost } from '../host/contracts.js';
+import { AnthropicMessagesAdapter } from '../model/anthropic-messages.js';
+import { OpenAiResponsesAdapter } from '../model/openai-responses.js';
+import { resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
+import { JsonlSessionStore } from '../session/jsonl-store.js';
+/** Validate models before Host negotiation and expose only built-in protocol adapters. */
+export async function createMarAgent(options) {
+    if (Object.hasOwn(options, 'adapterFactory'))
+        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Custom model adapters are not supported.');
+    return createMarAgentWithAdapter(options);
+}
+/** Package-internal seam for deterministic adapter tests; not a package export. */
+export async function createMarAgentWithAdapter(options) {
+    const rolloutBudgetOptions = resolveRolloutBudgetOptions(options.rolloutBudget);
+    const resolvedModels = resolveAgentModels(options.models);
+    let { models, defaultModelId } = resolvedModels;
+    let modelGeneration = 0;
+    const { credentialProviders } = resolvedModels;
+    const description = negotiateHost(await options.host.describe());
+    if (description.mode !== options.mode)
+        throw new MarAgentError('MAR_AGENT_HOST_INCOMPATIBLE', 'Host mode does not match Agent mode.');
+    const store = await JsonlSessionStore.open(description.homeDirectory);
+    const active = new Map();
+    const activeExecutionAdapters = new Set();
+    const executionResults = new Map();
+    const sessionRuntimes = new Map();
+    const sessionWriterOwner = {};
+    let disposed = false;
+    let reconfiguring = false;
+    const createAdapter = (modelId, configuredModels = models) => {
+        const configuration = configuredModels.get(modelId);
+        if (!configuration)
+            throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+        return (options.adapterFactory?.(configuration) ??
+            (configuration.protocol === 'OPENAI_RESPONSES'
+                ? new OpenAiResponsesAdapter(configuration)
+                : new AnthropicMessagesAdapter(configuration)));
+    };
+    const activeSessionIds = () => new Set([...active.keys()].map((key) => key.slice(0, key.indexOf(':'))));
+    const activeAdaptersExcept = (sessionId) => {
+        const activeAdapters = new Set();
+        for (const [candidateSessionId, runtime] of sessionRuntimes)
+            if (candidateSessionId !== sessionId && activeSessionIds().has(candidateSessionId))
+                for (const adapter of runtime.adapters.values())
+                    activeAdapters.add(adapter);
+        return activeAdapters;
+    };
+    const openSession = createSessionOpener({
+        host: options.host,
+        description,
+        settings: {
+            ...(options.workspaceMapping === undefined
+                ? {}
+                : { workspaceMapping: options.workspaceMapping }),
+            ...(options.systemInstruction === undefined
+                ? {}
+                : { systemInstruction: options.systemInstruction })
+        },
+        store,
+        registry: {
+            active,
+            activeExecutionAdapters,
+            executionResults,
+            sessionRuntimes,
+            sessionWriterOwner
+        },
+        rolloutBudgetOptions,
+        hasCustomAdapters: options.adapterFactory !== undefined,
+        modelState: () => ({ models, defaultModelId, generation: modelGeneration }),
+        createAdapter,
+        activeAdaptersExcept,
+        assertCanStart: () => {
+            if (disposed)
+                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
+            if (reconfiguring)
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models are being reconfigured for the next execution.');
+        }
+    });
+    return {
+        createSession: async (input) => openSession((await store.createSession(input)).id, input.workspace),
+        openSession: (id) => openSession(id),
+        listSessions: (input) => store.list(input),
+        clearSession: async (id) => {
+            const runtime = sessionRuntimes.get(id);
+            if ([...active.keys()].some((key) => key.startsWith(`${id}:`)))
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'A session cannot be cleared while an execution is active.');
+            await runtime?.subagents?.dispose();
+            await closeModelAdapters(runtime === undefined ? [] : [...runtime.adapters.values()]);
+            sessionRuntimes.delete(id);
+            await options.host.disposeSessionResources?.(id);
+            await store.clearSession(id);
+        },
+        reconfigureModels: async (input) => {
+            if (disposed)
+                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
+            if (reconfiguring)
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models are already being reconfigured for the next execution.');
+            const next = resolveAgentModels(input.models, input.defaultModelId);
+            const activeSessions = activeSessionIds();
+            if ([...activeSessions].some((sessionId) => sessionRuntimes.get(sessionId)?.sourceType !== 'subagent'))
+                throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while a main execution is active.');
+            const activeAdapters = new Set(activeExecutionAdapters);
+            for (const [sessionId, runtime] of sessionRuntimes)
+                if (activeSessions.has(sessionId))
+                    for (const adapter of runtime.adapters.values())
+                        activeAdapters.add(adapter);
+            const inactiveRuntimes = [...sessionRuntimes].flatMap(([sessionId, runtime]) => activeSessions.has(sessionId) ? [] : [runtime]);
+            reconfiguring = true;
+            try {
+                const reconfigurationCommits = new Map();
+                for (const runtime of inactiveRuntimes)
+                    for (const [modelId, adapter] of runtime.adapters) {
+                        if (activeAdapters.has(adapter))
+                            continue;
+                        const configuration = next.models.get(modelId);
+                        const commit = configuration === undefined ? undefined : adapter.prepareReconfigure?.(configuration);
+                        if (commit !== undefined)
+                            reconfigurationCommits.set(adapter, commit);
+                    }
+                const retainedAdapters = new Set(reconfigurationCommits.keys());
+                const adapters = [
+                    ...new Set(inactiveRuntimes.flatMap((runtime) => [...runtime.adapters.values()]))
+                ].filter((adapter) => !activeAdapters.has(adapter) && !retainedAdapters.has(adapter));
+                for (const runtime of inactiveRuntimes) {
+                    for (const [modelId, adapter] of runtime.adapters)
+                        if (!retainedAdapters.has(adapter))
+                            runtime.adapters.delete(modelId);
+                }
+                await closeModelAdapters(adapters);
+                if (disposed)
+                    throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
+                for (const commit of reconfigurationCommits.values())
+                    commit();
+                models = next.models;
+                defaultModelId = next.defaultModelId;
+                modelGeneration++;
+                for (const provider of next.credentialProviders)
+                    credentialProviders.add(provider);
+                for (const runtime of inactiveRuntimes) {
+                    runtime.adapterGeneration = modelGeneration;
+                }
+                const liveProviders = new Set(next.credentialProviders);
+                for (const adapter of activeExecutionAdapters)
+                    addModelCredentialProviders(liveProviders, adapter.configuration);
+                for (const runtime of sessionRuntimes.values())
+                    for (const adapter of runtime.adapters.values())
+                        addModelCredentialProviders(liveProviders, adapter.configuration);
+                const obsoleteProviders = [...credentialProviders].filter((provider) => !liveProviders.has(provider));
+                const providerCloseResults = await Promise.allSettled(obsoleteProviders.map((provider) => provider.close()));
+                for (const [index, result] of providerCloseResults.entries())
+                    if (result.status === 'fulfilled')
+                        credentialProviders.delete(obsoleteProviders[index]);
+            }
+            finally {
+                reconfiguring = false;
+            }
+        },
+        deleteSession: async (id) => {
+            const sessionIds = await store.sessionTree(id);
+            const sessionIdSet = new Set(sessionIds);
+            const executionKeys = [...active.keys()].filter((key) => sessionIdSet.has(key.slice(0, key.indexOf(':'))));
+            for (const key of executionKeys)
+                active.get(key)?.abort();
+            const runtimes = sessionIds.flatMap((sessionId) => {
+                const runtime = sessionRuntimes.get(sessionId);
+                sessionRuntimes.delete(sessionId);
+                return runtime === undefined ? [] : [runtime];
+            });
+            await Promise.all(runtimes.map((runtime) => runtime.subagents?.dispose()));
+            await Promise.allSettled(executionKeys.flatMap((key) => {
+                const result = executionResults.get(key);
+                return result === undefined ? [] : [result];
+            }));
+            await closeModelAdapters(runtimes.flatMap((runtime) => [...runtime.adapters.values()]));
+            await Promise.all(sessionIds.map((sessionId) => options.host.disposeSessionResources?.(sessionId)));
+            await store.delete(id);
+        },
+        dispose: async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const controller of active.values())
+                controller.abort();
+            await Promise.all([...sessionRuntimes.values()].map((runtime) => runtime.subagents?.dispose().catch(() => undefined)));
+            await Promise.allSettled([...executionResults.values()]);
+            await closeModelAdapters([...sessionRuntimes.values()].flatMap((runtime) => [...runtime.adapters.values()]));
+            let disposalError;
+            const providerResults = await Promise.allSettled([...credentialProviders].map((provider) => provider.close()));
+            disposalError = providerResults.find((result) => result.status === 'rejected')?.reason;
+            try {
+                await options.host.dispose();
+            }
+            catch (error) {
+                disposalError ??= error;
+            }
+            try {
+                await store.close();
+            }
+            catch (error) {
+                disposalError ??= error;
+            }
+            if (disposalError !== undefined)
+                throw disposalError;
+        }
+    };
+}

package/dist/agent-core/sdk/model-runtime.d.ts

@@ -0,0 +1,13 @@
+import { type MarAgentModelConfiguration, type MarAgentReasoningEffort, type ModelCredentialProvider } from '../model/configuration.js';
+import type { ModelAdapter, ModelTurnSession } from '../model/contracts.js';
+export type ResolvedModelConfiguration = MarAgentModelConfiguration & {
+    readonly defaultReasoningEffort: MarAgentReasoningEffort;
+};
+export declare function resolveAgentModels(configurations: readonly MarAgentModelConfiguration[], requestedDefaultModelId?: string): {
+    readonly models: Map<string, ResolvedModelConfiguration>;
+    readonly defaultModelId: string;
+    readonly credentialProviders: Set<ModelCredentialProvider>;
+};
+export declare function createModelTurnSession(adapter: ModelAdapter): ModelTurnSession;
+export declare function closeModelAdapters(adapters: Iterable<ModelAdapter>): Promise<void>;
+export declare function addModelCredentialProviders(target: Set<ModelCredentialProvider>, configuration: MarAgentModelConfiguration): void;