@myagentroam/agent 0.9.141 → 0.9.143

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,6 +1,9 @@
 import { MarAgentError } from '../../error.js';
-import type { ToolExecutionContext, ToolExecutionResult } from '../../sdk/types.js';
+import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
+import { type CodeObservation } from './observations.js';
 export interface CellOutput {
+    call(value: import('./observations.js').CodeToolCallRecord): void;
+    observe(value: CodeObservation): void;
     text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;

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

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { truncateModelText } from '../../runtime/token-budget.js';
+import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { BoundedTextOutput, renderCapturedText } from './text-output.js';
+import { boundObservations, selectObservationImages, newObservationId, visibleObservation } from './observations.js';
 /** Keeps a failed tool call observable without discarding earlier explicit output. */
 export class CodeCellExecutionError extends MarAgentError {
     result;
@@ -88,6 +89,9 @@ export class CodeCells {
             status: 'running',
             text: new BoundedTextOutput(limits.codeMaxOutputBytes),
             images: [],
+            observations: [],
+            calls: new Map(),
+            imageOffset: 0,
             yielded: false,
             truncated: false,
             listeners: new Set(),
@@ -104,6 +108,8 @@ export class CodeCells {
             .then(async () => {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal }, {
+                call: (value) => cell.calls.set(value.callId, value),
+                observe: (value) => cell.observations.push(value),
                 text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
@@ -199,6 +205,31 @@ export class CodeCells {
         if (!supportsImages && (cell.images.length || cell.terminal?.images?.length))
             throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'The current model cannot receive this cell image output.');
         if (cell.terminal) {
+            if (cell.terminal.observations) {
+                const bounded = boundObservations(cell.terminal.observations, input.maxOutputTokens);
+                const visible = selectObservationImages(bounded.observations, cell.terminal.images ?? []);
+                const original = cell.terminal.data;
+                const data = {
+                    ...original,
+                    output: truncateModelText(original.output ?? '', input.maxOutputTokens).content,
+                    observations: visible.observations,
+                    cached: true,
+                    truncated: cell.terminal.truncated === true || bounded.truncated
+                };
+                return {
+                    ...cell.terminal,
+                    observations: visible.observations,
+                    images: visible.images,
+                    content: JSON.stringify({
+                        ...data,
+                        output: undefined,
+                        calls: undefined,
+                        observations: visible.observations.map(visibleObservation)
+                    }),
+                    data,
+                    truncated: data.truncated
+                };
+            }
             const snapshot = cell.terminal.data;
             const bounded = truncateModelText(snapshot.output, input.maxOutputTokens);
             const data = {
@@ -219,7 +250,21 @@ export class CodeCells {
         const text = renderCapturedText(captured, images.length);
         cell.yielded = false;
         const bounded = truncateModelText(text, input.maxOutputTokens);
-        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated;
+        const pending = cell.observations.splice(0);
+        if (!pending.length && captured.text)
+            pending.push({
+                type: 'value',
+                id: newObservationId(),
+                format: 'text',
+                value: captured.text,
+                truncated: captured.droppedBytes > 0
+            });
+        const structured = boundObservations(pending, input.maxOutputTokens);
+        const visible = selectObservationImages(structured.observations, images, cell.imageOffset);
+        const remapped = visible.observations;
+        const visibleImages = visible.images;
+        cell.imageOffset += images.length;
+        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated || structured.truncated;
         const error = cell.error === undefined
             ? undefined
             : describeMarAgentError(cell.error, 'MAR_AGENT_CODE_FAILED');
@@ -227,6 +272,8 @@ export class CodeCells {
             cellId: cell.cellId,
             status: cell.status,
             output: bounded.content,
+            observations: remapped,
+            calls: [...cell.calls.values()],
             ...cell.result?.data,
             outputBytes: captured.originalBytes,
             outputDroppedBytes: captured.droppedBytes,
@@ -235,10 +282,17 @@ export class CodeCells {
             cached: false
         };
         const result = {
-            content: JSON.stringify(data),
+            content: JSON.stringify({
+                ...data,
+                output: undefined,
+                calls: undefined,
+                observations: remapped.map(visibleObservation)
+            }),
+            calls: [...cell.calls.values()],
+            observations: remapped,
             data,
-            truncated: cell.truncated,
-            ...(images.length ? { images } : {})
+            truncated: cell.truncated || structured.truncated,
+            ...(visibleImages.length ? { images: visibleImages } : {})
         };
         if (cell.status !== 'running')
             cell.terminal = result;
@@ -246,7 +300,7 @@ export class CodeCells {
         if (initial && cell.status !== 'running') {
             if (cell.error !== undefined)
                 throw new CodeCellExecutionError(cell.error, result);
-            return { ...result, content: bounded.content || 'Code Exec completed without emitted text.' };
+            return result;
         }
         return result;
     }

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,9 @@
 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 { allowsToolCaller } from '../callers.js';
+import { boundedModelToolOutput, 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]));
@@ -23,8 +23,8 @@ export function createCodeToolDispatch(input) {
                     signal,
                     ...(expected ? { expectedMcpTool: expected } : {})
                 });
-                const bounded = truncateModelText(result.content, AGENT_EXECUTION_POLICY.modelToolOutputTokens);
-                const data = input.projectData(call.name, result.data);
+                const bounded = boundedModelToolOutput(call.name, result.content, 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',
@@ -36,7 +36,11 @@ export function createCodeToolDispatch(input) {
                         summary.length < result.content.length,
                     ...(result.artifacts ? { artifacts: result.artifacts } : {})
                 });
-                return { ...result, content: bounded.content };
+                return {
+                    ...result,
+                    content: bounded.content,
+                    truncated: result.truncated === true || bounded.truncated
+                };
             }
             catch (error) {
                 const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');

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;
@@ -32,6 +32,18 @@ export interface CodeModeEngine {
         onToolCall(call: ToolCall): Promise<ProgrammaticToolResult>;
         onText(value: string, originalBytes?: number): void;
         onImage(value: unknown): void;
+        onObserve(value: {
+            type: 'tool_result';
+            operationId: string;
+        } | {
+            type: 'value';
+            format: 'text' | 'json';
+            value: string;
+            originalBytes: number;
+        } | {
+            type: 'image';
+            value: unknown;
+        }): void;
         onYield(): void;
     }): Promise<{
         readonly stateMutations: readonly CodeModeStateMutation[];

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

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