@myagentroam/agent 0.9.141 → 0.9.142

package/dist/agent-core/sdk/subagent-backend.d.ts

@@ -0,0 +1,3 @@
+import type { JsonlSessionStore } from '../session/jsonl-store.js';
+import type { SubagentSessionControllerBackend } from '../subagent/session-controller.js';
+export declare function createSubagentBackend(store: JsonlSessionStore, workspace: string): SubagentSessionControllerBackend;

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

@@ -0,0 +1,46 @@
+import { MarAgentError } from '../error.js';
+export function createSubagentBackend(store, workspace) {
+    return {
+        createSession: async (input) => {
+            const session = await store.createSession({
+                workspace,
+                title: input.title,
+                source: input.source
+            });
+            return { id: session.id };
+        },
+        deleteSession: async (sessionId) => {
+            await store.delete(sessionId);
+        },
+        listChildren: async (parentSessionId) => {
+            const sessions = await store.listSubagentChildren(parentSessionId);
+            return Promise.all(sessions.map(async (session) => ({
+                id: session.id,
+                createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
+                source: session.source,
+                records: await store.read(session.id)
+            })));
+        },
+        loadChild: async (parentSessionId, childSessionId) => {
+            let session;
+            try {
+                session = await store.getSession(childSessionId);
+            }
+            catch (error) {
+                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND')
+                    return undefined;
+                throw error;
+            }
+            if (session.source.type !== 'subagent' || session.source.parentSessionId !== parentSessionId)
+                return undefined;
+            return {
+                id: session.id,
+                createdAt: session.createdAt,
+                lastActivityAt: session.lastActivityAt,
+                source: session.source,
+                records: await store.read(session.id)
+            };
+        }
+    };
+}

package/dist/agent-core/sdk/types.d.ts

@@ -0,0 +1,56 @@
+import type { MarAgentHost } from '../host/contracts.js';
+import type { MarAgentModelConfiguration } from '../model/configuration.js';
+import type { ExecutionResult, RolloutBudgetOptions, RunInput } from '../runtime/contracts.js';
+import type { MarAgentEvent } from '../runtime/events.js';
+import type { MarAgentSessionPage, MarAgentSessionSummary } from '../session/catalog.js';
+import type { SessionListInput, SessionSource } from '../session/types.js';
+export interface CreateSessionInput {
+    workspace: string;
+    title?: string;
+}
+export type { HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill, MarAgentHost } from '../host/contracts.js';
+export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from '../runtime/contracts.js';
+export type { MarAgentEvent, MarAgentEventBase } from '../runtime/events.js';
+export type { CodeCellEventData, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../tools/contracts.js';
+/** A live execution exposes streamed events separately from its terminal result. */
+export interface ExecutionHandle extends AsyncIterable<MarAgentEvent> {
+    readonly executionId: string;
+    result(): Promise<ExecutionResult>;
+    /** Signals abort; await result() to observe the terminal status and cleanup. */
+    cancel(): void;
+}
+/** A persisted Session permits one active main execution at a time. */
+export interface MarAgentSession {
+    readonly id: string;
+    run(input: RunInput): ExecutionHandle;
+    plan(input: RunInput): ExecutionHandle;
+    compact(input?: Partial<RunInput>): ExecutionHandle;
+    cancel(executionId: string): Promise<void>;
+}
+export interface MarAgent {
+    createSession(input: CreateSessionInput): Promise<MarAgentSession>;
+    openSession(sessionId: string): Promise<MarAgentSession>;
+    listSessions(input?: SessionListInput): Promise<MarAgentSessionPage>;
+    clearSession(sessionId: string): Promise<void>;
+    /** Rebinds future main executions only; running subagents keep their captured model providers. */
+    reconfigureModels(input: {
+        readonly models: readonly MarAgentModelConfiguration[];
+        readonly defaultModelId?: string;
+    }): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    /** Cancels active executions, then closes SDK-owned providers, the Host and the Session store. */
+    dispose(): Promise<void>;
+}
+export interface CreateMarAgentOptions {
+    mode: 'normal' | 'node';
+    host: MarAgentHost;
+    models: readonly MarAgentModelConfiguration[];
+    defaultModelId?: string;
+    systemInstruction?: string;
+    workspaceMapping?: {
+        readonly logicalPath: string;
+        readonly physicalPath: string;
+    };
+    rolloutBudget?: false | RolloutBudgetOptions;
+}
+export type { MarAgentSessionSummary, SessionListInput, SessionSource };

package/dist/{session → agent-core/session}/catalog.d.ts

@@ -1,5 +1,6 @@
+import type { MarAgentImageMetadata } from '../runtime/contracts.js';
+import type { MarAgentEvent } from '../runtime/events.js';
 import type { SessionListInput, SessionSource } from './types.js';
-import type { MarAgentEvent, MarAgentImageMetadata } from '../sdk/types.js';
 export interface MarAgentSessionSummary {
     id: string;
     title: string;

package/dist/{session → agent-core/session}/context-gc-checkpoint.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { posix, win32 } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { parseReadContextOutput } from '../tools/read-context.js';
+import { parseReadContextOutput } from '../tools/local/read-context.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from './context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, normalizeContextGcSubagentSnapshot } from './context-gc-subagent.js';
 export const CONTEXT_GC_CHECKPOINT_VERSION = 1;

package/dist/{session → agent-core/session}/jsonl-store.d.ts

@@ -1,7 +1,7 @@
 import type { ModelUsage } from '../model/contracts.js';
-import type { EnvironmentContextState } from '../prompts/core.js';
+import type { EnvironmentContextState } from '../runtime/context/contracts.js';
 import { type CodeModeStateEntry } from '../tools/code-mode/state.js';
-import { type TodoSnapshot } from '../tools/todo.js';
+import { type TodoSnapshot } from '../tools/agent/todo.js';
 import { type ContextGcCheckpointDraft } from './context-gc-checkpoint.js';
 import type { SessionListInput, SessionSource } from './types.js';
 export type { SessionListInput, SessionSource } from './types.js';

package/dist/{session → agent-core/session}/jsonl-store.js

@@ -6,7 +6,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { isDeepStrictEqual } from 'node:util';
 import { MarAgentError } from '../error.js';
 import { applyCodeModeStateMutations, parseCodeModeStateMutations, restoreCodeModeState } from '../tools/code-mode/state.js';
-import { todoItemsFromSnapshot } from '../tools/todo.js';
+import { todoItemsFromSnapshot } from '../tools/agent/todo.js';
 import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageGrowth, contextGcSourceProjectionHash, latestValidContextGcCheckpoint, normalizeContextGcReplacements, parseContextGcCheckpoint, sameContextGcBase, validateContextGcCheckpoint } from './context-gc-checkpoint.js';
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from './transaction-recovery.js';
 const MAX_SEGMENT_BYTES = 16 * 1024 * 1024;

package/dist/agent-core/subagent/contracts.d.ts

@@ -0,0 +1,91 @@
+import type { MarAgentReasoningEffort } from '../model/configuration.js';
+export interface SubagentTaskInput {
+    description: string;
+    prompt: string;
+    role: 'general-purpose' | 'explore';
+    modelId?: string;
+    reasoningEffort?: MarAgentReasoningEffort;
+    background?: boolean;
+    parentSubagentId?: string;
+}
+export interface SubagentTaskResult {
+    summary: string;
+    changedFiles: string[];
+    verification: string[];
+    evidence: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+    }>;
+}
+export interface SubagentLatestMessage {
+    itemId: string;
+    turnId: string;
+    phase: 'commentary' | 'final_answer';
+    text: string;
+    timestamp: string;
+    truncated: boolean;
+}
+export type SubagentLatestActivity = {
+    kind: 'message';
+    timestamp: string;
+    phase: 'commentary' | 'final_answer';
+} | {
+    kind: 'tool';
+    timestamp: string;
+    toolName: string;
+    status: 'started' | 'completed' | 'failed';
+};
+export interface SubagentTaskSnapshot extends Record<string, unknown> {
+    agentId: string;
+    description: string;
+    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    modelId?: string;
+    modelName?: string;
+    reasoningEffort?: MarAgentReasoningEffort;
+    latestMessage?: SubagentLatestMessage;
+    latestActivity?: SubagentLatestActivity;
+    summary?: string;
+    changedFiles?: string[];
+    verification?: string[];
+    evidence?: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+    }>;
+    errorCode?: string;
+    errorMessage?: string;
+    messageId?: string;
+    turnId?: string;
+    deliveryStatus?: 'accepted' | 'applied' | 'cancelled' | 'failed';
+    waitOutcome?: SubagentWaitOutcome;
+}
+export type SubagentWaitFor = 'completion' | 'message';
+export type SubagentWaitOutcome = 'snapshot' | 'message' | 'completion' | 'timeout';
+export interface SubagentMessageOptions {
+    delivery?: 'append' | 'replace';
+    signal?: AbortSignal;
+}
+export interface SubagentRunOptions {
+    signal?: AbortSignal;
+    onCreated?: (task: SubagentTaskSnapshot) => Promise<void> | void;
+}
+export interface SubagentOutputOptions {
+    waitMs?: number;
+    waitFor?: SubagentWaitFor;
+    signal?: AbortSignal;
+}
+export interface SubagentController {
+    beginExecution?(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
+    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
+    output(agentId: string, options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    outputAny(options?: SubagentOutputOptions): Promise<SubagentTaskSnapshot>;
+    message(agentId: string, message: string, options?: SubagentMessageOptions): Promise<SubagentTaskSnapshot>;
+    cancel(agentId: string): Promise<SubagentTaskSnapshot>;
+    listSessionResources(): readonly {
+        agentId: string;
+        status: SubagentTaskSnapshot['status'];
+        description: string;
+    }[];
+    dispose(): Promise<void>;
+}

package/dist/agent-core/subagent/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/agent-core/subagent/scheduler.d.ts

@@ -0,0 +1,117 @@
+import type { SubagentController, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot } from './contracts.js';
+export type { SubagentController, SubagentLatestActivity, SubagentLatestMessage, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskResult, SubagentTaskSnapshot, SubagentWaitFor, SubagentWaitOutcome } from './contracts.js';
+export declare class SubagentScheduler implements SubagentController {
+    #private;
+    readonly limits: {
+        maxTasks: number;
+        maxConcurrent: number;
+    };
+    constructor(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>, limits?: {
+        maxTasks: number;
+        maxConcurrent: number;
+    });
+    beginExecution(runner: (task: SubagentTaskInput, signal: AbortSignal) => Promise<SubagentTaskResult>): void;
+    run(input: SubagentTaskInput, options?: SubagentRunOptions): Promise<SubagentTaskSnapshot>;
+    output(agentId: string, options?: SubagentOutputOptions): Promise<{
+        waitOutcome: "snapshot";
+        agentId: string;
+        description: string;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
+        latestMessage?: import("./contracts.js").SubagentLatestMessage;
+        latestActivity?: import("./contracts.js").SubagentLatestActivity;
+        summary?: string;
+        changedFiles?: string[];
+        verification?: string[];
+        evidence?: Array<{
+            path: string;
+            startLine?: number;
+            endLine?: number;
+        }>;
+        errorCode?: string;
+        errorMessage?: string;
+        messageId?: string;
+        turnId?: string;
+        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
+    } | {
+        waitOutcome: "completion" | "timeout";
+        agentId: string;
+        description: string;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
+        latestMessage?: import("./contracts.js").SubagentLatestMessage;
+        latestActivity?: import("./contracts.js").SubagentLatestActivity;
+        summary?: string;
+        changedFiles?: string[];
+        verification?: string[];
+        evidence?: Array<{
+            path: string;
+            startLine?: number;
+            endLine?: number;
+        }>;
+        errorCode?: string;
+        errorMessage?: string;
+        messageId?: string;
+        turnId?: string;
+        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
+    }>;
+    outputAny(options?: SubagentOutputOptions): Promise<{
+        waitOutcome: "snapshot";
+        agentId: string;
+        description: string;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
+        latestMessage?: import("./contracts.js").SubagentLatestMessage;
+        latestActivity?: import("./contracts.js").SubagentLatestActivity;
+        summary?: string;
+        changedFiles?: string[];
+        verification?: string[];
+        evidence?: Array<{
+            path: string;
+            startLine?: number;
+            endLine?: number;
+        }>;
+        errorCode?: string;
+        errorMessage?: string;
+        messageId?: string;
+        turnId?: string;
+        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
+    } | {
+        waitOutcome: "completion" | "timeout";
+        agentId: string;
+        description: string;
+        status: "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: import("../model/configuration.js").MarAgentReasoningEffort;
+        latestMessage?: import("./contracts.js").SubagentLatestMessage;
+        latestActivity?: import("./contracts.js").SubagentLatestActivity;
+        summary?: string;
+        changedFiles?: string[];
+        verification?: string[];
+        evidence?: Array<{
+            path: string;
+            startLine?: number;
+            endLine?: number;
+        }>;
+        errorCode?: string;
+        errorMessage?: string;
+        messageId?: string;
+        turnId?: string;
+        deliveryStatus?: "accepted" | "applied" | "cancelled" | "failed";
+    }>;
+    cancel(agentId: string): Promise<SubagentTaskSnapshot>;
+    message(_agentId: string, _message: string): Promise<SubagentTaskSnapshot>;
+    listSessionResources(): {
+        agentId: string;
+        status: "completed" | "failed" | "cancelled" | "running" | "queued";
+        description: string;
+    }[];
+    dispose(): Promise<void>;
+}

package/dist/{subagent → agent-core/subagent}/session-controller.d.ts

@@ -1,5 +1,6 @@
 import type { MarAgentReasoningEffort } from '../model/configuration.js';
-import type { MarAgentEvent, ExecutionResult } from '../sdk/types.js';
+import type { ExecutionResult } from '../runtime/contracts.js';
+import type { MarAgentEvent } from '../runtime/events.js';
 import type { SessionRecord, SessionSource } from '../session/jsonl-store.js';
 import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions, SubagentRunOptions, SubagentTaskInput, SubagentTaskSnapshot } from './scheduler.js';
 export interface SubagentModelOption {
@@ -93,7 +94,7 @@ export declare class SubagentSessionController implements SubagentController {
     cancel(agentId: string): Promise<SubagentTaskSnapshot>;
     listSessionResources(): {
         agentId: string;
-        status: "completed" | "cancelled" | "running" | "queued" | "failed" | "interrupted";
+        status: "completed" | "failed" | "cancelled" | "running" | "queued" | "interrupted";
         description: string;
     }[];
     dispose(): Promise<void>;

package/dist/agent-core/tools/agent/agent-cancel.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
+export declare const agentCancelToolDefinition: ClientToolDefinition;
+export declare function executeAgentCancel(arguments_: unknown, context: ToolRuntimeContext): Promise<{
+    content: string;
+    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
+}>;

package/dist/{tools → agent-core/tools/agent}/agent-cancel.js

@@ -1,4 +1,4 @@
-import { MarAgentError } from '../error.js';
+import { MarAgentError } from '../../error.js';
 export const agentCancelToolDefinition = {
     name: 'agent_cancel',
     allowedCallers: ['direct', 'programmatic'],

package/dist/agent-core/tools/agent/agent-message.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
+export declare const agentMessageToolDefinition: ClientToolDefinition;
+export declare function executeAgentMessage(arguments_: unknown, context: ToolRuntimeContext): Promise<{
+    content: string;
+    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
+}>;

package/dist/{tools → agent-core/tools/agent}/agent-message.js

@@ -1,5 +1,5 @@
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentMessageToolDefinition = {
     name: 'agent_message',
     allowedCallers: ['direct', 'programmatic'],

package/dist/{tools → agent-core/tools/agent}/agent-start.d.ts

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const agentStartToolDefinition: ClientToolDefinition;
 export declare function agentStartToolDefinitionWithModels(models: readonly {
     readonly id: string;
@@ -8,5 +8,5 @@ export declare function agentStartToolDefinitionWithModels(models: readonly {
 }[]): ClientToolDefinition;
 export declare function executeAgentStart(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;
-    data: import("../subagent/scheduler.js").SubagentTaskSnapshot;
+    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
 }>;

package/dist/{tools → agent-core/tools/agent}/agent-start.js

@@ -1,6 +1,6 @@
-import { MarAgentError } from '../error.js';
-import { marAgentReasoningEffortSchema } from '../model/configuration.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { marAgentReasoningEffortSchema } from '../../model/configuration.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentStartToolDefinition = {
     name: 'agent_start',
     allowedCallers: ['direct', 'programmatic'],

package/dist/agent-core/tools/agent/agent-wait.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
+export declare const agentWaitToolDefinition: ClientToolDefinition;
+export declare function executeAgentWait(arguments_: unknown, context: ToolRuntimeContext): Promise<{
+    content: string;
+    data: import("../../subagent/contracts.js").SubagentTaskSnapshot;
+}>;

package/dist/{tools → agent-core/tools/agent}/agent-wait.js

@@ -1,5 +1,5 @@
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const agentWaitToolDefinition = {
     name: 'agent_wait',
     allowedCallers: ['direct', 'programmatic'],

package/dist/{tools → agent-core/tools/agent}/question.d.ts

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const questionToolDefinition: ClientToolDefinition;
 export declare function executeQuestion(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;

package/dist/{tools → agent-core/tools/agent}/question.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const questionToolDefinition = {
     name: 'question',
     allowedCallers: ['direct'],

package/dist/{tools → agent-core/tools/agent}/skill.d.ts

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const skillToolDefinition: ClientToolDefinition;
 export declare function executeSkill(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;

package/dist/{tools → agent-core/tools/agent}/skill.js

@@ -1,5 +1,5 @@
-import { MarAgentError } from '../error.js';
-import { agentSkillSource, loadAgentSkill } from '../runtime/instructions.js';
+import { MarAgentError } from '../../error.js';
+import { agentSkillSource, loadAgentSkill } from '../../runtime/context/instructions.js';
 export const skillToolDefinition = {
     name: 'skill',
     allowedCallers: ['direct'],

package/dist/{tools → agent-core/tools/agent}/todo-read.d.ts

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const todoReadToolDefinition: ClientToolDefinition;
 export declare function executeTodoRead(context: ToolRuntimeContext): Promise<{
     content: string;

package/dist/{tools → agent-core/tools/agent}/todo-write.d.ts

@@ -1,5 +1,5 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const todoWriteToolDefinition: ClientToolDefinition;
 export declare function executeTodoWrite(arguments_: unknown, context: ToolRuntimeContext): Promise<{
     content: string;

package/dist/{tools → agent-core/tools/agent}/todo-write.js

@@ -1,5 +1,5 @@
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const todoWriteToolDefinition = {
     name: 'todo_write',
     allowedCallers: ['direct', 'programmatic'],

package/dist/{tools → agent-core/tools/agent}/todo.d.ts

@@ -1,12 +1,5 @@
-export interface TodoItem {
-    id: string;
-    step: string;
-    status: 'pending' | 'in_progress' | 'completed';
-}
-export interface TodoSnapshot {
-    revision: number;
-    items: TodoItem[];
-}
+import type { TodoItem, TodoSnapshot } from '../contracts.js';
+export type { TodoItem, TodoSnapshot } from '../contracts.js';
 export declare class TodoStore {
     #private;
     static restore(snapshot: TodoSnapshot): TodoStore;

package/dist/{tools → agent-core/tools/agent}/todo.js

@@ -1,4 +1,4 @@
-import { MarAgentError } from '../error.js';
+import { MarAgentError } from '../../error.js';
 export class TodoStore {
     #revision = 0;
     #items = [];

package/dist/{tools → agent-core/tools}/code-mode/cells.d.ts

@@ -1,5 +1,5 @@
 import { MarAgentError } from '../../error.js';
-import type { ToolExecutionContext, ToolExecutionResult } from '../../sdk/types.js';
+import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
 export interface CellOutput {
     text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;

package/dist/{tools → agent-core/tools}/code-mode/dispatch.d.ts

@@ -1,5 +1,6 @@
 import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { MarAgentEvent, ToolCall, ToolExecutionResult, McpToolCallContext } from '../../sdk/types.js';
+import type { MarAgentEvent } from '../../runtime/events.js';
+import type { McpToolCallContext, ToolCall, ToolExecutionResult } from '../contracts.js';
 import type { ToolRuntimeContext } from '../runtime-context.js';
 import type { createSessionToolScheduler } from '../scheduler.js';
 type ToolEvent = Extract<MarAgentEvent, {
@@ -14,8 +15,5 @@ export declare function createCodeToolDispatch(input: {
     parentCallId: string;
     schedule: ReturnType<typeof createSessionToolScheduler>;
     emit: (event: Payload) => Promise<void>;
-    projectData: (name: string, data: unknown) => Extract<ToolEvent, {
-        type: 'tool.completed';
-    }>['data'];
 }): (call: ToolCall, signal: AbortSignal) => Promise<ToolExecutionResult>;
 export {};

package/dist/{tools → agent-core/tools}/code-mode/dispatch.js

@@ -1,9 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
-import { executeRegisteredTool } from '../runtime.js';
-import { allowsToolCaller } from '../callers.js';
-import { truncateModelText } from '../../runtime/token-budget.js';
 import { AGENT_EXECUTION_POLICY } from '../../runtime/execution-policy.js';
+import { truncateModelText } from '../../runtime/token-budget.js';
+import { allowsToolCaller } from '../callers.js';
+import { structuredToolEventData } from '../output-projection.js';
+import { executeRegisteredTool } from '../runtime.js';
 /** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */
 export function createCodeToolDispatch(input) {
     const definitions = new Map(input.tools.map((tool) => [tool.name, tool]));
@@ -24,7 +25,7 @@ export function createCodeToolDispatch(input) {
                     ...(expected ? { expectedMcpTool: expected } : {})
                 });
                 const bounded = truncateModelText(result.content, AGENT_EXECUTION_POLICY.modelToolOutputTokens);
-                const data = input.projectData(call.name, result.data);
+                const data = structuredToolEventData(call.name, result.data);
                 const summary = result.content.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
                 await input.emit({
                     type: 'tool.completed',

package/dist/{tools → agent-core/tools}/code-mode/engine.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCall, ToolExecutionResult } from '../../sdk/types.js';
+import type { ToolCall, ToolExecutionResult } from '../contracts.js';
 import type { CodeModeStateEntry, CodeModeStateMutation } from './state.js';
 export type ProgrammaticToolResult = Omit<ToolExecutionResult, 'content'> & {
     content?: string;

package/dist/agent-core/tools/code-mode/engine.js

@@ -0,0 +1 @@
+export {};

package/dist/{tools/code-mode.d.ts → agent-core/tools/code-mode/index.d.ts}

@@ -1,9 +1,9 @@
-import { type LocalProcessExecutor } from '../host/local-process-executor.js';
-import type { ClientToolDefinition, ModelMessage } from '../model/contracts.js';
-import type { ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
-import type { CodeModeEngineFactory } from './code-mode/engine.js';
-import { type CellOutput } from './code-mode/cells.js';
+import { type LocalProcessExecutor } from '../../host/local-process-executor.js';
+import type { ClientToolDefinition, ModelMessage } from '../../model/contracts.js';
+import { type CellOutput } from './cells.js';
+import type { CodeModeEngineFactory } from './engine.js';
+import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
 export declare const codeModeToolDefinition: ClientToolDefinition;
 export declare const codeExecWaitToolDefinition: ClientToolDefinition;
 /** Deferred definitions travel in search results, not in the stable Code Mode description. */
@@ -20,7 +20,7 @@ export declare class CodeModeTool {
     wait(value: unknown, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     listSessionResources(sessionId: string): {
         cellId: string;
-        status: "completed" | "cancelled" | "running" | "failed";
+        status: "completed" | "failed" | "cancelled" | "running";
         executionId: string;
     }[];
     constructor(paths: WorkspacePathResolver, environment?: NodeJS.ProcessEnv, executor?: LocalProcessExecutor, engineFactory?: CodeModeEngineFactory);