@myagentroam/agent 0.11.32 → 0.11.34

package/dist/sdk/extension-models.d.ts

@@ -0,0 +1,17 @@
+import type { SessionModelRequest as ModelRequest } from '../session/model-request.js';
+import type { ExtensionModelsBackend } from '../extensions/models.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ExtensionModelRequest, ExtensionRequestSnapshot } from '../extensions/model-request.js';
+import type { ModelAdapter } from '../model/contracts.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+export declare function createExtensionModels(state: () => {
+    models: ReadonlyMap<string, ResolvedModelConfiguration>;
+    defaultModelId: string;
+}, createAdapter: (modelId: string, models: ReadonlyMap<string, ResolvedModelConfiguration>) => ModelAdapter, activeAdapters: {
+    add(adapter: ModelAdapter): void;
+    delete(adapter: ModelAdapter): void;
+}, resolveSnapshot?: (snapshot: ExtensionRequestSnapshot, call: ExtensionOperationContext) => {
+    modelId: string;
+    request: ModelRequest;
+    view: ExtensionModelRequest;
+}, observeUsage?: (usage: import('../model/usage-observer.js').ModelRequestUsage, call: ExtensionOperationContext) => Promise<void> | void): ExtensionModelsBackend;

package/dist/sdk/extension-models.js

@@ -0,0 +1,142 @@
+import { randomUUID } from 'node:crypto';
+import { projectModelRequest } from './model-input-projection.js';
+import { AgentError } from '../error.js';
+import { ExtensionRequestBridge } from '../extensions/model-request.js';
+import { transformCoreModelStream } from '../extensions/model-stream.js';
+import { modelTextInput } from '../model/text-blocks.js';
+export function createExtensionModels(state, createAdapter, activeAdapters, resolveSnapshot, observeUsage) {
+    return {
+        list: () => {
+            const { models, defaultModelId } = state();
+            return Object.freeze([...models.values()].map((model) => Object.freeze({
+                id: model.id,
+                name: model.name,
+                modelId: model.modelId,
+                contextWindowTokens: model.contextWindowTokens,
+                maxOutputTokens: model.maxOutputTokens,
+                inputCapabilities: Object.freeze([...model.inputCapabilities]),
+                reasoningEfforts: Object.freeze([...model.reasoningEfforts]),
+                isDefault: model.id === defaultModelId
+            })));
+        },
+        async generate(input, call, transform, transformEvent, diagnoseCleanup) {
+            call.signal.throwIfAborted();
+            const { models, defaultModelId } = state();
+            const snapshot = input.requestSnapshot === undefined
+                ? undefined
+                : resolveSnapshot?.(input.requestSnapshot, call);
+            if (input.requestSnapshot !== undefined && !snapshot)
+                throw new AgentError('MAR_AGENT_MODEL_SNAPSHOT_INVALID', 'Request snapshot is unavailable.');
+            if (input.retainToolCatalog && !snapshot)
+                throw new AgentError('MAR_AGENT_MODEL_SNAPSHOT_INVALID', 'A retained tool catalog requires a real request snapshot.');
+            const modelId = input.modelId ?? snapshot?.modelId ?? defaultModelId;
+            const configuration = models.get(modelId);
+            if (!configuration)
+                throw new AgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
+            if (input.outputLimit !== undefined &&
+                (!Number.isSafeInteger(input.outputLimit) || input.outputLimit < 1))
+                throw new AgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'Output limit must be a positive integer.');
+            const adapter = createAdapter(modelId, models);
+            activeAdapters.add(adapter);
+            let failed = false;
+            try {
+                const system = input.system === undefined ? undefined : modelTextInput(input.system);
+                const prompt = input.prompt === undefined ? undefined : modelTextInput(input.prompt);
+                const { systemBlocks: capturedBlocks, ...captured } = snapshot?.request ?? {};
+                const systemBlocks = system ? system.blocks : capturedBlocks;
+                const bridge = new ExtensionRequestBridge(modelId, {
+                    ...captured,
+                    system: system?.text ?? snapshot?.request.system ?? '',
+                    ...(systemBlocks === undefined ? {} : { systemBlocks }),
+                    messages: snapshot?.request.messages ?? [],
+                    tools: input.retainToolCatalog ? snapshot.request.tools : [],
+                    toolChoice: 'none'
+                }, snapshot?.view.messages);
+                const view = await transform({
+                    ...bridge.view,
+                    messages: [
+                        ...(input.messages ?? bridge.view.messages),
+                        ...(prompt
+                            ? [
+                                {
+                                    role: 'user',
+                                    content: prompt.text,
+                                    ...(prompt.blocks === undefined ? {} : { textBlocks: prompt.blocks })
+                                }
+                            ]
+                            : [])
+                    ],
+                    ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {})
+                });
+                const lowered = bridge.lower(view);
+                if (lowered.tools.length && !input.retainToolCatalog)
+                    throw new AgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'Independent generation does not execute tools.');
+                const request = {
+                    ...lowered,
+                    usageRequestId: randomUUID(),
+                    ...(observeUsage === undefined
+                        ? {}
+                        : {
+                            onModelUsage: (usage) => observeUsage(usage, call),
+                            onModelUsageFailure: () => diagnoseCleanup?.('MAR_AGENT_MODEL_USAGE_FAILED')
+                        }),
+                    ...(input.retainToolCatalog &&
+                        snapshot.request.systemBlocks === undefined &&
+                        snapshot.request.messages.every((message) => message.textBlocks === undefined)
+                        ? { cachePrefixMessages: Math.max(0, lowered.messages.length - (prompt ? 1 : 0)) }
+                        : {}),
+                    toolChoice: 'none',
+                    allowTools: input.retainToolCatalog === true,
+                    outputLimit: Math.min(input.outputLimit ?? configuration.maxOutputTokens, configuration.maxOutputTokens)
+                };
+                let text = '';
+                const chunks = new Map();
+                let stopReason;
+                let usage;
+                for await (const event of transformCoreModelStream((signal) => adapter.start(projectModelRequest(request), signal), call.signal, transformEvent, () => diagnoseCleanup?.('MAR_AGENT_MODEL_STREAM_CLEANUP_FAILED'))) {
+                    call.signal.throwIfAborted();
+                    if (event.type === 'text.delta' && event.phase === 'final_answer')
+                        chunks.set(event.itemId, (chunks.get(event.itemId) ?? '') + event.delta);
+                    else if (event.type === 'text.completed' && event.phase !== 'commentary')
+                        chunks.set(event.itemId, event.text);
+                    else if (event.type === 'output.reset')
+                        chunks.clear();
+                    else if (event.type === 'usage')
+                        usage = { ...event.usage };
+                    else if (event.type === 'completed')
+                        stopReason = event.reason;
+                    else if (event.type === 'client_tool.call' && !input.retainToolCatalog)
+                        throw new AgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'Independent generation received a tool call.');
+                }
+                call.signal.throwIfAborted();
+                if (!stopReason)
+                    throw new AgentError('MAR_AGENT_MODEL_STREAM_INCOMPLETE', 'Model stream ended without a terminal outcome.');
+                text = [...chunks.values()].join('');
+                return {
+                    outcome: stopReason === 'cancelled' ? 'cancelled' : text ? 'text' : 'empty',
+                    text,
+                    stopReason,
+                    ...(usage ? { usage: Object.freeze(usage) } : {})
+                };
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                try {
+                    await adapter.close?.();
+                }
+                catch (error) {
+                    // eslint-disable-next-line no-unsafe-finally -- Preserve a primary failure; surface cleanup failures after success.
+                    if (!failed)
+                        throw error;
+                    diagnoseCleanup?.('MAR_AGENT_MODEL_ADAPTER_CLEANUP_FAILED');
+                }
+                finally {
+                    activeAdapters.delete(adapter);
+                }
+            }
+        }
+    };
+}

package/dist/sdk/extension-session-launch.d.ts

@@ -0,0 +1,18 @@
+import { type ExtensionSessionActionResult, type ExtensionSessionRequest, type SessionInputEntry } from '../extensions/session-input.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ExecutionMode, RunInput } from './types.js';
+import type { InternalExecutionHandle, InternalExecutionOptions } from './session-execution.js';
+/** Adapts committed Extension input to an independently owned Execution. */
+export declare function createExtensionSessionLaunch(sourceType: 'user' | 'subagent', start: (mode: ExecutionMode, input: RunInput, options: InternalExecutionOptions) => InternalExecutionHandle): (entry: SessionInputEntry, request: Exclude<ExtensionSessionRequest, {
+    kind: "append";
+}>, call: ExtensionOperationContext) => Promise<InternalExecutionHandle & {
+    inputCommitted: Promise<ExtensionSessionActionResult>;
+}>;
+export declare function extensionInputSource(call: ExtensionOperationContext, provenance?: string, modelAttribution?: 'none'): {
+    modelAttribution?: "none";
+    provenance?: string;
+    ownerInstanceId?: string;
+    extensionId?: string;
+    operationId: string;
+    actor: "model" | "sdk" | "extension" | "code-mode";
+};

package/dist/sdk/extension-session-launch.js

@@ -0,0 +1,73 @@
+import { AgentError } from '../error.js';
+import { DEFAULT_COMPACTION_FOCUS } from '../runtime/compaction/history.js';
+import { recordSessionInputCommit } from '../extensions/session-input.js';
+/** Adapts committed Extension input to an independently owned Execution. */
+export function createExtensionSessionLaunch(sourceType, start) {
+    return async (entry, request, call) => {
+        if (sourceType !== 'user')
+            throw new AgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Idle subagent input must use its task controller.');
+        let resolveInput;
+        let rejectInput;
+        const inputCommitted = new Promise((resolve, reject) => {
+            resolveInput = resolve;
+            rejectInput = reject;
+        });
+        void inputCommitted.catch(() => undefined);
+        const handle = start(request.kind === 'compact' ? 'compact' : 'run', {
+            prompt: request.kind === 'compact'
+                ? (request.input.focus ?? DEFAULT_COMPACTION_FOCUS)
+                : request.input.text,
+            ...(request.kind === 'submit' && request.input.images !== undefined
+                ? { images: request.input.images }
+                : {})
+        }, {
+            automaticInput: true,
+            inputCommitted: (recordId) => {
+                const outcome = { changed: true, recordId, executionId: handle.executionId };
+                recordSessionInputCommit(entry, outcome);
+                resolveInput(outcome);
+            },
+            ...(request.kind === 'submit' ? { promptAdmitted: true } : {}),
+            ...(call.actor === 'sdk' && call.extensionId === undefined
+                ? {}
+                : { inputSource: 'extension' }),
+            ...(request.kind === 'submit' && request.input.modelText !== undefined
+                ? { modelText: request.input.modelText }
+                : {}),
+            ...(request.kind === 'submit' && request.input.context !== undefined
+                ? { inputContext: request.input.context }
+                : {}),
+            ...(request.kind === 'submit' && request.input.modelContext !== undefined
+                ? { modelContext: request.input.modelContext }
+                : {}),
+            ...(call.actor === 'sdk' && call.extensionId === undefined
+                ? {}
+                : {
+                    extensionSource: extensionInputSource(call, request.kind === 'submit' ? request.input.provenance : undefined, request.kind === 'submit' ? request.input.modelAttribution : undefined)
+                })
+        });
+        void handle.result().then((result) => {
+            if (request.kind === 'compact')
+                resolveInput({
+                    changed: result.status === 'completed',
+                    executionId: handle.executionId
+                });
+            else
+                rejectInput(new AgentError(result.errorCode ??
+                    (result.status === 'cancelled'
+                        ? 'MAR_AGENT_EXECUTION_CANCELLED'
+                        : 'MAR_AGENT_SESSION_INPUT_FAILED'), 'Execution ended before its input record was committed.'));
+        }, rejectInput);
+        return Object.assign(handle, { inputCommitted });
+    };
+}
+export function extensionInputSource(call, provenance, modelAttribution) {
+    return {
+        operationId: call.operationId,
+        actor: call.actor,
+        ...(call.extensionId ? { extensionId: call.extensionId } : {}),
+        ...(call.ownerInstanceId ? { ownerInstanceId: call.ownerInstanceId } : {}),
+        ...(provenance !== undefined ? { provenance } : {}),
+        ...(modelAttribution === undefined ? {} : { modelAttribution })
+    };
+}

package/dist/sdk/extension-session.d.ts

@@ -0,0 +1,30 @@
+import type { ExecutionHandle } from './types.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { ExtensionRequestSnapshot } from '../extensions/model-request.js';
+import type { ExtensionPromptComposition, ExtensionPromptFacts } from '../extensions/prompt-composition.js';
+import { SessionInputCoordinator, type ExtensionSessionBackend, type ExtensionSessionRequest, type SessionInputEntry, type ExtensionSessionMessages, type ExtensionSessionMessagesInput, type ExtensionSessionActionResult } from '../extensions/session-input.js';
+import type { ExtensionSessionDescription } from '../extensions/session-input.js';
+export interface ExtensionSessionPorts {
+    describe?(call: ExtensionOperationContext): Promise<ExtensionSessionDescription>;
+    composePrompt?(facts: ExtensionPromptFacts, call: ExtensionOperationContext): Promise<ExtensionPromptComposition>;
+    captureRequest(call: ExtensionOperationContext, input?: {
+        readonly completed?: boolean;
+    }): Promise<ExtensionRequestSnapshot | undefined>;
+    readonly sessionId: string;
+    coordinator(): SessionInputCoordinator;
+    activeExecutionId(): string | undefined;
+    messages(input: ExtensionSessionMessagesInput, call: ExtensionOperationContext): Promise<ExtensionSessionMessages>;
+    append(entry: SessionInputEntry, request: Extract<ExtensionSessionRequest, {
+        kind: 'append';
+    }>, call: ExtensionOperationContext): Promise<ExtensionSessionActionResult>;
+    launch(entry: SessionInputEntry, request: Exclude<ExtensionSessionRequest, {
+        kind: 'append';
+    }>, call: ExtensionOperationContext): Promise<ExecutionHandle & {
+        readonly inputCommitted: Promise<ExtensionSessionActionResult>;
+    }>;
+    diagnose(code: string, operationId: string): void;
+}
+/** Admission and idle execution reuse the same Session coordinator and SDK entry. */
+export declare function createExtensionSessionBackend(ports: ExtensionSessionPorts): ExtensionSessionBackend & {
+    kick(): void;
+};

package/dist/sdk/extension-session.js

@@ -0,0 +1,107 @@
+import { AgentError } from '../error.js';
+/** Admission and idle execution reuse the same Session coordinator and SDK entry. */
+export function createExtensionSessionBackend(ports) {
+    let scheduled;
+    const idleLeaf = async (entry, request, call) => {
+        call.signal.throwIfAborted();
+        if (request.kind === 'append')
+            return ports.append(entry, request, call);
+        const handle = await ports.launch(entry, request, call);
+        ports.coordinator().startExecution(entry, handle.executionId);
+        const cancel = () => handle.cancel();
+        call.signal.addEventListener('abort', cancel, { once: true });
+        if (call.signal.aborted)
+            cancel();
+        const completion = handle
+            .result()
+            .then((result) => {
+            ports.coordinator().settleExecution(handle.executionId, result.status);
+            return result;
+        })
+            .finally(() => call.signal.removeEventListener('abort', cancel));
+        if (request.kind === 'compact') {
+            const result = await completion;
+            if (result.status !== 'completed')
+                throw new AgentError(result.errorCode ?? 'MAR_AGENT_COMPACT_FAILED', 'Requested compaction did not complete.');
+        }
+        else {
+            void completion.catch(() => ports.diagnose('MAR_AGENT_SESSION_INPUT_FAILED', call.operationId));
+            return await handle.inputCommitted;
+        }
+        return { changed: true, executionId: handle.executionId };
+    };
+    const kick = () => {
+        if (scheduled ||
+            ports.activeExecutionId() ||
+            ports.coordinator().executing ||
+            !ports.coordinator().hasPending)
+            return;
+        scheduled = Promise.resolve()
+            .then(async () => {
+            if (!ports.activeExecutionId())
+                await ports.coordinator().drain(idleLeaf, undefined, 1);
+        })
+            .catch(() => ports.diagnose('MAR_AGENT_SESSION_INPUT_FAILED', 'idle-admission'))
+            .finally(() => {
+            scheduled = undefined;
+            kick();
+        });
+    };
+    return {
+        ...(ports.describe
+            ? { describe: (call) => ports.describe(call) }
+            : {}),
+        ...(ports.composePrompt
+            ? {
+                composePrompt: (facts, call) => ports.composePrompt(facts, call)
+            }
+            : {}),
+        captureRequest: (call, input) => ports.captureRequest(call, input),
+        kick,
+        inspect: async (call) => {
+            call.signal.throwIfAborted();
+            const executionId = ports.activeExecutionId();
+            return {
+                sessionId: ports.sessionId,
+                epoch: call.sessionEpoch,
+                ...(executionId ? { activeExecutionId: executionId } : {}),
+                operations: ports.coordinator().inspect()
+            };
+        },
+        messages: (input, call) => ports.messages(input, call),
+        handled: (input, call, value) => ports.coordinator().handled(input, call, value),
+        own: (id) => {
+            const coordinator = ports.coordinator();
+            return () => coordinator.retire(id);
+        },
+        enqueue: async (request, call, action) => {
+            const coordinator = ports.coordinator();
+            if (request.kind === 'append' && request.input.delivery === 'immediate') {
+                try {
+                    return await coordinator.performAppend(request.input, call, action, (entry, value, effective) => {
+                        if (value.kind !== 'append')
+                            throw new AgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Immediate record submission must remain an append.');
+                        return ports.append(entry, value, effective);
+                    });
+                }
+                finally {
+                    kick();
+                }
+            }
+            const current = request.kind === 'compact' ? coordinator.currentCompact() : undefined;
+            if (current)
+                throw new AgentError('MAR_AGENT_COMPACT_REENTRANT', 'Recursive compaction is not allowed.');
+            const idle = !ports.activeExecutionId() && !coordinator.executing;
+            const entry = coordinator.accept(request, call, action, request.kind === 'submit' ? 'accepted' : 'queued');
+            kick();
+            if (idle && request.kind === 'submit' && request.input.waitFor === 'start')
+                await entry.started;
+            else if ((idle &&
+                request.kind !== 'submit' &&
+                !(request.kind === 'compact' && request.input.async)) ||
+                (request.kind === 'submit' && request.input.waitFor === 'commit'))
+                await entry.terminal;
+            return Object.freeze({ ...entry.receipt });
+        }
+    };
+}

package/dist/sdk/extension-tool-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionToolRuntime } from '../extensions/tool-runtime.js';
+export declare const extensionToolRuntime: ExtensionToolRuntime;

package/dist/sdk/extension-tool-runtime.js

@@ -0,0 +1,14 @@
+import { currentToolPermissions } from '../tools/permissions.js';
+import { normalizeToolInput } from '../tools/input.js';
+import { validateToolResult } from '../tools/output-projection.js';
+import { withIndependentSessionTools } from '../tools/scheduler.js';
+import { toolCallers } from '../tools/callers.js';
+import { assertMcpToolCatalog } from '../tools/mcp/catalog.js';
+export const extensionToolRuntime = {
+    currentPermissions: currentToolPermissions,
+    normalizeInput: normalizeToolInput,
+    validateResult: validateToolResult,
+    independent: withIndependentSessionTools,
+    validateCallers: toolCallers,
+    validateMcpCatalog: (catalog) => assertMcpToolCatalog(catalog, { nativeToolNames: true })
+};

package/dist/sdk/extension-tools.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionToolBinding } from '../extensions/tools.js';
+import type { ClientToolDefinition, McpToolCatalog } from '../tools/contracts.js';
+import { type RoundToolScope } from '../tools/execution.js';
+import type { ToolRuntimeContext } from '../tools/runtime-context.js';
+/** One real Execution's sources; a retained physical frame is distinct from its active main round. */
+export declare class ExecutionToolSources {
+    #private;
+    readonly executionId: string;
+    readonly sessionId: string;
+    readonly bindings: readonly ExtensionToolBinding[];
+    constructor(executionId: string, sessionId: string, definitions: readonly ClientToolDefinition[], builtins: readonly ClientToolDefinition[], catalog: McpToolCatalog, supplemental?: readonly ExtensionToolBinding[]);
+    bind(scope: RoundToolScope): void;
+    assertActive(): void;
+    withFrame<Value>(context: ToolRuntimeContext, run: () => Value): Value;
+    close(): void;
+}

package/dist/sdk/extension-tools.js

@@ -0,0 +1,126 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+import { AgentError } from '../error.js';
+import { toolCallers } from '../tools/callers.js';
+import { createRoundToolRuntimeContext } from '../tools/execution.js';
+import { executeCapturedTool } from '../tools/runtime.js';
+/** One real Execution's sources; a retained physical frame is distinct from its active main round. */
+export class ExecutionToolSources {
+    executionId;
+    sessionId;
+    bindings;
+    #frame = new AsyncLocalStorage();
+    #scope;
+    #closed = false;
+    constructor(executionId, sessionId, definitions, builtins, catalog, supplemental = []) {
+        this.executionId = executionId;
+        this.sessionId = sessionId;
+        this.bindings = Object.freeze([
+            ...definitions.map((original) => {
+                const captured = catalog.tools.find((tool) => tool.definition.name === original.name);
+                const mcp = captured === undefined ? undefined : structuredClone(captured);
+                const kind = mcp ? 'mcp' : builtins.includes(original) ? 'builtin' : 'host';
+                const definition = Object.freeze({
+                    ...structuredClone(original),
+                    allowedCallers: Object.freeze([...toolCallers(original)])
+                });
+                return Object.freeze({
+                    definition,
+                    source: Object.freeze({
+                        kind,
+                        id: mcp?.sourceIdentity ?? `${kind}:${executionId}:${definition.name}`,
+                        revision: mcp?.definitionRevision ?? executionId
+                    }),
+                    ...(mcp === undefined ? {} : { mcp }),
+                    available: (call) => {
+                        const context = this.#context(call);
+                        if (!context)
+                            return false;
+                        if (definition.name === 'skill')
+                            return context.skills.size > 0;
+                        if (['agent_start', 'agent_wait', 'agent_message', 'agent_cancel'].includes(definition.name))
+                            return context.subagents !== undefined;
+                        if (definition.name === 'tool_search')
+                            return (this.#currentFrame()?.searchMcpTools !== undefined || this.#scope !== undefined);
+                        return true;
+                    },
+                    invoke: async (input, call) => {
+                        const context = this.#context(call);
+                        if (!context)
+                            throw unavailable();
+                        const frame = this.#currentFrame();
+                        const scope = this.#scope;
+                        const actual = frame ??
+                            (scope &&
+                                (await createRoundToolRuntimeContext(scope, { ...input, callId: input.callId ?? randomUUID() }, call.signal)));
+                        if (!actual || !this.#context(call))
+                            throw unavailable();
+                        call.signal.throwIfAborted();
+                        return executeCapturedTool(kind, input, {
+                            ...actual,
+                            signal: call.signal,
+                            ...(mcp === undefined
+                                ? {}
+                                : {
+                                    expectedMcpTool: {
+                                        sourceIdentity: mcp.sourceIdentity,
+                                        definitionRevision: mcp.definitionRevision
+                                    }
+                                })
+                        });
+                    }
+                });
+            }),
+            ...supplemental
+        ]);
+    }
+    bind(scope) {
+        if (this.#closed ||
+            scope.context.executionId !== this.executionId ||
+            scope.context.sessionId !== this.sessionId)
+            throw unavailable();
+        this.#scope = scope;
+    }
+    assertActive() {
+        if (this.#closed)
+            throw unavailable();
+    }
+    withFrame(context, run) {
+        if (context.executionId !== this.executionId || context.sessionId !== this.sessionId)
+            throw unavailable();
+        const frame = { context, active: true };
+        return this.#frame.run(frame, () => {
+            try {
+                const result = run();
+                if (result instanceof Promise)
+                    return result.finally(() => {
+                        frame.active = false;
+                    });
+                frame.active = false;
+                return result;
+            }
+            catch (error) {
+                frame.active = false;
+                throw error;
+            }
+        });
+    }
+    close() {
+        this.#closed = true;
+        this.#scope = undefined;
+    }
+    #context(call) {
+        if (call.executionId !== this.executionId || call.sessionId !== this.sessionId)
+            return;
+        const frame = this.#currentFrame();
+        const context = frame ?? (this.#closed ? undefined : this.#scope?.context);
+        return context && !context.signal.aborted ? context : undefined;
+    }
+    #currentFrame() {
+        const frame = this.#frame.getStore();
+        return frame?.active ? frame.context : undefined;
+    }
+}
+function unavailable() {
+    return new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Execution tool source is unavailable.');
+}

package/dist/sdk/model-input-projection.d.ts

@@ -0,0 +1,4 @@
+import type { ModelRequest } from '../model/contracts.js';
+import type { SessionModelRequest } from '../session/model-request.js';
+/** Project without mutating execution history, the captured request or its retry state. */
+export declare function projectModelRequest(request: SessionModelRequest): ModelRequest;

package/dist/sdk/model-input-projection.js

@@ -0,0 +1,27 @@
+import { observationModelParts } from '../session/code-observation-projection.js';
+function projectTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        ...(tool.nativeType === undefined ? {} : { nativeType: tool.nativeType }),
+        ...(tool.inputMode === undefined ? {} : { inputMode: tool.inputMode })
+    };
+}
+function projectMessage(message) {
+    const { calls: _calls, observations: _observations, observationId: _id, toolSearchTools, ...input } = message;
+    const parts = message.role === 'tool' ? observationModelParts(message) : undefined;
+    return {
+        ...input,
+        ...(parts === undefined ? {} : { contentParts: parts }),
+        ...(toolSearchTools === undefined ? {} : { toolSearchTools: toolSearchTools.map(projectTool) })
+    };
+}
+/** Project without mutating execution history, the captured request or its retry state. */
+export function projectModelRequest(request) {
+    return {
+        ...request,
+        messages: request.messages.map(projectMessage),
+        tools: request.tools.map(projectTool)
+    };
+}

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

@@ -0,0 +1,21 @@
+import { type AgentModelConfiguration, type AgentReasoningEffort, type ModelCredentialProvider } from '../model/configuration.js';
+import type { ModelAdapter, ModelTurnSession } from '../model/contracts.js';
+export type ResolvedModelConfiguration = AgentModelConfiguration & {
+    readonly defaultReasoningEffort: AgentReasoningEffort;
+};
+export declare function resolveAgentModels(configurations: readonly AgentModelConfiguration[], requestedDefaultModelId?: string): {
+    readonly models: Map<string, ResolvedModelConfiguration>;
+    readonly defaultModelId: string;
+    readonly credentialProviders: Set<ModelCredentialProvider>;
+};
+export declare function createModelTurnSession(adapter: ModelAdapter): ModelTurnSession;
+/** Owns only one Execution's model turn and explicitly transferred adapters. */
+export declare function createExecutionModelResources(activeAdapters: {
+    add(adapter: ModelAdapter): void;
+    delete(adapter: ModelAdapter): void;
+}): {
+    openTurn(adapter: ModelAdapter, ownsAdapter: boolean): ModelTurnSession;
+    close(): Promise<void>;
+};
+export declare function closeModelAdapters(adapters: Iterable<ModelAdapter>): Promise<void>;
+export declare function addModelCredentialProviders(target: Set<ModelCredentialProvider>, configuration: AgentModelConfiguration): void;