@myagentroam/agent 0.11.33 → 0.11.34

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

@@ -1,137 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { MarAgentError } 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, 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 MarAgentError('MAR_AGENT_MODEL_SNAPSHOT_INVALID', 'Request snapshot is unavailable.');
-            if (input.retainToolCatalog && !snapshot)
-                throw new MarAgentError('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 MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');
-            if (input.outputLimit !== undefined &&
-                (!Number.isSafeInteger(input.outputLimit) || input.outputLimit < 1))
-                throw new MarAgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'Output limit must be a positive integer.');
-            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 MarAgentError('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)
-            };
-            const adapter = createAdapter(modelId, models);
-            let text = '';
-            const chunks = new Map();
-            let stopReason;
-            let usage;
-            let failed = false;
-            try {
-                for await (const event of transformCoreModelStream((signal) => adapter.start(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 MarAgentError('MAR_AGENT_MODEL_REQUEST_INVALID', 'Independent generation received a tool call.');
-                }
-                call.signal.throwIfAborted();
-                if (!stopReason)
-                    throw new MarAgentError('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');
-                }
-            }
-        }
-    };
-}

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

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

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

@@ -1,105 +0,0 @@
-import { MarAgentError } 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 MarAgentError(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 MarAgentError('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 MarAgentError('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/agent-core/sdk/extension-tools.d.ts

@@ -1,16 +0,0 @@
-import type { CoreToolBinding } 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 CoreToolBinding[];
-    constructor(executionId: string, sessionId: string, definitions: readonly ClientToolDefinition[], builtins: readonly ClientToolDefinition[], catalog: McpToolCatalog, supplemental?: readonly CoreToolBinding[]);
-    bind(scope: RoundToolScope): void;
-    assertActive(): void;
-    withFrame<Value>(context: ToolRuntimeContext, run: () => Value): Value;
-    close(): void;
-}

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

@@ -1,126 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { randomUUID } from 'node:crypto';
-import { MarAgentError } 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 MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Execution tool source is unavailable.');
-}

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

@@ -1,18 +0,0 @@
-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;
-/** Owns only one Execution's model turn and explicitly transferred adapters. */
-export declare function createExecutionModelResources(activeAdapters: Set<ModelAdapter>): {
-    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: MarAgentModelConfiguration): void;

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

@@ -1,93 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { resolveModelDefaultReasoningEffort } from '../model/configuration.js';
-import { observeModelProgress } from '../runtime/model-progress.js';
-export function resolveAgentModels(configurations, requestedDefaultModelId) {
-    const configuredModels = configurations.map((model) => ({
-        ...model,
-        defaultReasoningEffort: resolveModelDefaultReasoningEffort(model)
-    }));
-    const credentialProviders = new Set();
-    for (const model of configuredModels) {
-        if ((model.apiKey === undefined) === (model.credentialProvider === undefined))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Exactly one model credential source is required.');
-        if (model.fastMode === true && model.protocol !== 'OPENAI_RESPONSES')
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Fast mode requires Responses.');
-        if (model.serviceTier !== undefined &&
-            (model.protocol !== 'OPENAI_RESPONSES' ||
-                !['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'].includes(model.serviceTier)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses service tier is invalid.');
-        if (model.credentialProvider !== undefined)
-            credentialProviders.add(model.credentialProvider);
-    }
-    const models = new Map(configuredModels.filter((model) => model.enabled).map((model) => [model.id, model]));
-    if (models.size === 0)
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'At least one enabled model is required.');
-    const defaultModelId = requestedDefaultModelId ??
-        [...models.values()].find((model) => model.conversationModel !== false)?.id;
-    if (!defaultModelId ||
-        !models.has(defaultModelId) ||
-        models.get(defaultModelId).conversationModel === false)
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default conversation model is unavailable.');
-    return { models, defaultModelId, credentialProviders };
-}
-export function createModelTurnSession(adapter) {
-    const turn = adapter.createTurnSession?.() ?? {
-        start: (request, signal) => adapter.start(request, signal),
-        close: async () => undefined
-    };
-    return {
-        async *start(request, signal) {
-            const before = request.retryState?.attempts;
-            try {
-                yield* observeModelProgress((requestSignal) => turn.start(request, requestSignal), signal);
-            }
-            finally {
-                // Custom adapters may not participate in the shared attempt accounting.
-                if (request.retryState && request.retryState.attempts === before)
-                    request.retryState.attempts++;
-            }
-        },
-        resetContinuation: () => turn.resetContinuation?.(),
-        continuationInputCount: () => turn.continuationInputCount?.() ?? 0,
-        commitContinuationInput: (count) => turn.commitContinuationInput?.(count),
-        close: () => turn.close()
-    };
-}
-/** Owns only one Execution's model turn and explicitly transferred adapters. */
-export function createExecutionModelResources(activeAdapters) {
-    let turn;
-    const ownedAdapters = new Set();
-    return {
-        openTurn(adapter, ownsAdapter) {
-            if (ownsAdapter) {
-                ownedAdapters.add(adapter);
-                activeAdapters.add(adapter);
-            }
-            turn = createModelTurnSession(adapter);
-            return turn;
-        },
-        async close() {
-            await turn?.close().catch(() => undefined);
-            try {
-                await closeModelAdapters(ownedAdapters);
-            }
-            catch {
-                // Model cleanup must not replace the Execution result.
-            }
-            finally {
-                for (const adapter of ownedAdapters)
-                    activeAdapters.delete(adapter);
-            }
-        }
-    };
-}
-export async function closeModelAdapters(adapters) {
-    const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
-    const failure = results.find((result) => result.status === 'rejected');
-    if (failure !== undefined)
-        throw failure.reason;
-}
-export function addModelCredentialProviders(target, configuration) {
-    if (configuration.credentialProvider !== undefined)
-        target.add(configuration.credentialProvider);
-}

package/dist/agent-core/sdk/native-steer.d.ts

@@ -1,20 +0,0 @@
-import type { CoreOperationContext } from '../extensions/operation.js';
-import { type CorePromptInput, type CorePromptResult } from '../extensions/prompt-input.js';
-import type { SessionInputCoordinator } from '../extensions/session-input.js';
-import type { SessionRecord } from '../session/store/index.js';
-import type { SteerInput, SteerResult } from './types.js';
-/** Admission reserves the existing FIFO before any asynchronous Hook or writer work. */
-export declare function createNativeSteer(input: {
-    readonly executionId: string;
-    readonly inputs: SessionInputCoordinator;
-    readonly signal: AbortSignal;
-    isOpen(): boolean;
-    operation<T>(action: (call: CoreOperationContext) => T): T;
-    admit(content: CorePromptInput, call: CoreOperationContext, write: (content: CorePromptInput, call: CoreOperationContext) => Promise<CorePromptResult>): Promise<unknown>;
-    receive(content: CorePromptInput, clientMessageId: string, call: CoreOperationContext): Promise<SessionRecord>;
-    notify(entry: Extract<SteerResult, {
-        status: 'accepted';
-    }>['entry']): Promise<unknown>;
-    diagnose(): void;
-    wake(): void;
-}): (request: SteerInput) => Promise<SteerResult>;

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

@@ -1,84 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { captureCorePromptInput } from '../extensions/prompt-input.js';
-import { imageMetadata } from '../session/catalog.js';
-/** Admission reserves the existing FIFO before any asynchronous Hook or writer work. */
-export function createNativeSteer(input) {
-    const retries = new Map();
-    let admissionTail = Promise.resolve();
-    return async (request) => {
-        if (request.expectedExecutionId !== input.executionId)
-            return Promise.resolve({ status: 'notAccepted' });
-        const previous = retries.get(request.clientMessageId);
-        if (previous)
-            return previous;
-        if (!input.isOpen() || input.signal.aborted || input.inputs.hasIdleBarrier)
-            return Promise.resolve({ status: 'notAccepted' });
-        if (typeof request.clientMessageId !== 'string' ||
-            !request.clientMessageId.trim() ||
-            request.clientMessageId.length > 512)
-            return Promise.reject(new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'A stable client message ID is required.'));
-        const content = captureCorePromptInput({
-            text: request.prompt,
-            ...(request.modelText === undefined ? {} : { modelText: request.modelText }),
-            ...(request.images === undefined ? {} : { images: request.images })
-        });
-        const result = Promise.withResolvers();
-        const ready = Promise.withResolvers();
-        const entry = input.operation((call) => input.inputs.accept({ kind: 'submit', input: content }, call, (request, effective, next) => next(request, effective), 'accepted'));
-        entry.nativeSteer = { ready: ready.promise };
-        const aborted = () => ready.resolve();
-        input.signal.addEventListener('abort', aborted, { once: true });
-        let committed = false;
-        const admission = admissionTail
-            .catch(() => undefined)
-            .then(() => input.operation((call) => input.admit(content, call, async (actual, effective) => {
-            if (committed)
-                return {};
-            effective.signal.throwIfAborted();
-            if (!input.isOpen()) {
-                result.resolve({ status: 'notAccepted' });
-                return {};
-            }
-            const record = await input.receive(actual, request.clientMessageId, effective);
-            committed = true;
-            entry.nativeSteer.recordId = record.recordId;
-            const payload = record.payload;
-            const images = imageMetadata(payload.images);
-            const historyEntry = {
-                kind: 'user',
-                recordId: record.recordId,
-                sequence: record.sequence,
-                timestamp: record.timestamp,
-                sessionId: record.sessionId,
-                executionId: record.executionId,
-                turnId: record.turnId,
-                text: payload.prompt,
-                clientMessageId: request.clientMessageId,
-                ...(images.length ? { images } : {})
-            };
-            // Neither Hook post-processing nor a failed observer can revoke the writer's receipt.
-            void input.notify(historyEntry).catch(() => input.diagnose());
-            ready.resolve();
-            result.resolve({ status: 'accepted', entry: historyEntry });
-            input.wake();
-            return {};
-        })));
-        void admission
-            .then(() => {
-            if (!committed)
-                result.resolve({ status: 'handled' });
-        }, (error) => {
-            if (!committed)
-                result.reject(error);
-            else
-                input.diagnose();
-        })
-            .finally(() => {
-            ready.resolve();
-            input.signal.removeEventListener('abort', aborted);
-        });
-        admissionTail = result.promise;
-        retries.set(request.clientMessageId, result.promise);
-        return result.promise;
-    };
-}

package/dist/agent-core/sdk/request-preparation.d.ts

@@ -1,7 +0,0 @@
-import type { MarAgentModelConfiguration } from '../model/configuration.js';
-import type { ClientToolDefinition, ModelMessage, ModelRequest } from '../model/contracts.js';
-import { type ContextualWorldState } from '../runtime/context/world-state.js';
-/** Assemble captured round values only. Admission, Hooks and publication belong to Session. */
-export declare function prepareSessionModelRequest(candidate: ModelRequest, model: Pick<MarAgentModelConfiguration, 'protocol' | 'inputCapabilities'>, entries: ContextualWorldState['entries'], residentTools: readonly ClientToolDefinition[], autoPermission: boolean): ModelRequest;
-/** The actual candidate and current Session view share the same side-effect-free projection. */
-export declare function projectSessionRequestMessages(messages: readonly ModelMessage[], entries: ContextualWorldState['entries'], supportsImages: boolean, codeMode: boolean, autoPermission?: boolean): ModelMessage[];