@myagentroam/agent 0.11.33 → 0.11.34

package/dist/agent-core/tools/code-mode/observations.d.ts

@@ -1,98 +0,0 @@
-import type { ModelImage } from '../../model/image.js';
-/** Execution metadata is independent of explicit model observations. */
-export interface CodeToolCallRecord {
-    callId: string;
-    toolName: string;
-    input: unknown;
-    status: 'running' | 'completed' | 'failed';
-    resultExtensions?: readonly import('../result-extensions.js').ToolResultExtension[];
-    result?: {
-        content: string;
-        data?: unknown;
-        truncated?: boolean;
-    };
-    error?: {
-        code: string;
-        message: string;
-    };
-}
-export declare function parseCodeCalls(value: unknown): CodeToolCallRecord[] | undefined;
-export type CodeObservation = {
-    type: 'tool_result';
-    id: string;
-    source: {
-        callId: string;
-        toolName: string;
-        input: unknown;
-    };
-    outcome: 'completed' | 'failed';
-    result: {
-        content: string;
-        data?: unknown;
-        truncated?: boolean;
-        imageIndices?: number[];
-    };
-} | {
-    type: 'value';
-    id: string;
-    format: 'text' | 'json' | 'image';
-    value: string;
-    truncated?: boolean;
-    imageIndices?: number[];
-};
-export declare function observationContent(value: CodeObservation): string;
-export declare function observationImages(value: CodeObservation): readonly number[];
-export declare function selectObservationImages(values: readonly CodeObservation[], images: readonly ModelImage[], offset?: number): {
-    observations: ({
-        result: {
-            imageIndices: number[];
-            content: string;
-            data?: unknown;
-            truncated?: boolean;
-        };
-        type: "tool_result";
-        id: string;
-        source: {
-            callId: string;
-            toolName: string;
-            input: unknown;
-        };
-        outcome: "completed" | "failed";
-    } | {
-        imageIndices: number[];
-        type: "value";
-        id: string;
-        format: "text" | "json" | "image";
-        value: string;
-        truncated?: boolean;
-    })[];
-    images: ModelImage[];
-};
-/** Only the visible projection crosses into model text; program data and inputs stay private. */
-export declare function visibleObservation(value: CodeObservation): Record<string, unknown>;
-export declare function renderObservations(values: readonly CodeObservation[]): string;
-export declare function renderObservationResult(values: readonly CodeObservation[], original: string): string;
-/** Truncate each body before encoding, never a JSON array or its trusted identity. */
-export declare function boundObservations(values: readonly CodeObservation[], maximumTokens: number): {
-    observations: CodeObservation[];
-    content: string;
-    truncated: boolean;
-};
-export declare function newObservationId(): string;
-export declare function observationModelParts(message: {
-    content?: string;
-    textBlocks?: readonly {
-        readonly text: string;
-    }[];
-    observations?: readonly CodeObservation[];
-    images?: readonly import('../../model/image.js').ModelImage[];
-}): Array<{
-    type: 'text';
-    text: string;
-} | {
-    type: 'image';
-    image: import('../../model/image.js').ModelImage;
-}> | undefined;
-/** Uses the same visible text as both adapters, without pixels or private observation data. */
-export declare function observationModelText(message: Parameters<typeof observationModelParts>[0]): string | undefined;
-export declare function parseObservations(value: unknown): CodeObservation[] | undefined;

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

@@ -1,228 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { truncateModelText, countModelTokens } from '../../runtime/token-budget.js';
-export function parseCodeCalls(value) {
-    if (!Array.isArray(value) || value.length > 128)
-        return undefined;
-    const ids = new Set();
-    for (const item of value) {
-        if (!item ||
-            typeof item !== 'object' ||
-            typeof item.callId !== 'string' ||
-            !item.callId ||
-            ids.has(item.callId) ||
-            typeof item.toolName !== 'string' ||
-            !['running', 'completed', 'failed'].includes(item.status))
-            return undefined;
-        if (item.result !== undefined && (!item.result || typeof item.result.content !== 'string'))
-            return undefined;
-        ids.add(item.callId);
-    }
-    return value;
-}
-export function observationContent(value) {
-    return value.type === 'tool_result' ? value.result.content : value.value;
-}
-export function observationImages(value) {
-    return value.type === 'tool_result'
-        ? (value.result.imageIndices ?? [])
-        : (value.imageIndices ?? []);
-}
-export function selectObservationImages(values, images, offset = 0) {
-    const selected = [];
-    const indices = new Map();
-    const observations = values.map((value) => {
-        const remap = observationImages(value).flatMap((index) => {
-            const image = images[index - offset];
-            if (!image)
-                return [];
-            let next = indices.get(index);
-            if (next === undefined) {
-                next = selected.length;
-                indices.set(index, next);
-                selected.push(image);
-            }
-            return [next];
-        });
-        return value.type === 'tool_result'
-            ? { ...value, result: { ...value.result, imageIndices: remap } }
-            : { ...value, imageIndices: remap };
-    });
-    return { observations, images: selected };
-}
-/** Only the visible projection crosses into model text; program data and inputs stay private. */
-export function visibleObservation(value) {
-    return value.type === 'tool_result'
-        ? {
-            type: value.type,
-            toolName: value.source.toolName,
-            outcome: value.outcome,
-            content: value.result.content,
-            ...(value.result.truncated ? { truncated: true } : {})
-        }
-        : {
-            type: value.type,
-            format: value.format,
-            value: value.value,
-            ...(value.truncated ? { truncated: true } : {})
-        };
-}
-export function renderObservations(values) {
-    return JSON.stringify(values.map(visibleObservation));
-}
-function visibleObservationText(value) {
-    const { content: _content, value: _value, ...header } = visibleObservation(value);
-    const body = observationContent(value);
-    return JSON.stringify(header) + (body.length ? `\n${body}` : '');
-}
-export function renderObservationResult(values, original) {
-    try {
-        const envelope = JSON.parse(original);
-        if (envelope && !Array.isArray(envelope) && typeof envelope === 'object')
-            return JSON.stringify({ ...envelope, observations: values.map(visibleObservation) });
-    }
-    catch {
-        // A non-JSON envelope falls back to the bounded observation rendering.
-    }
-    return renderObservations(values);
-}
-/** Truncate each body before encoding, never a JSON array or its trusted identity. */
-export function boundObservations(values, maximumTokens) {
-    let remaining = Math.max(0, maximumTokens - 2);
-    let truncated = false;
-    const observations = [];
-    const selected = [];
-    let overheadBudget = 0;
-    for (const original of values) {
-        const empty = original.type === 'tool_result'
-            ? { ...original, result: { ...original.result, content: '', truncated: true } }
-            : { ...original, value: '', truncated: true };
-        const overhead = countModelTokens(visibleObservationText(empty)) + 8;
-        if (overheadBudget + overhead > remaining) {
-            truncated = true;
-            break;
-        }
-        selected.push({ original, overhead });
-        overheadBudget += overhead;
-    }
-    for (const { original, overhead } of selected) {
-        let bodyBudget = Math.max(0, remaining - overheadBudget - 12);
-        let value;
-        let bodyTruncated = false;
-        for (;;) {
-            const bounded = truncateModelText(observationContent(original), bodyBudget);
-            bodyTruncated ||= bounded.truncated;
-            value =
-                original.type === 'tool_result'
-                    ? {
-                        ...original,
-                        result: {
-                            ...original.result,
-                            content: bounded.content,
-                            truncated: original.result.truncated === true || bodyTruncated
-                        }
-                    }
-                    : {
-                        ...original,
-                        value: bounded.content,
-                        truncated: original.truncated === true || bodyTruncated
-                    };
-            if (countModelTokens(visibleObservationText(value)) + 1 <=
-                remaining - (overheadBudget - overhead) ||
-                bodyBudget === 0)
-                break;
-            bodyBudget = Math.floor(bodyBudget / 2);
-        }
-        overheadBudget -= overhead;
-        observations.push(value);
-        remaining -= countModelTokens(visibleObservationText(value)) + 1;
-        truncated ||=
-            bodyTruncated ||
-                (original.type === 'tool_result'
-                    ? original.result.truncated === true
-                    : original.truncated === true);
-    }
-    return { observations, content: renderObservations(observations), truncated };
-}
-export function newObservationId() {
-    return randomUUID();
-}
-export function observationModelParts(message) {
-    if (message.textBlocks !== undefined || message.observations === undefined)
-        return undefined;
-    const prefix = [];
-    try {
-        const parsed = JSON.parse(message.content ?? '');
-        if (parsed && !Array.isArray(parsed) && typeof parsed === 'object') {
-            const { observations: _observations, ...metadata } = parsed;
-            const cellEnvelope = typeof metadata.cellId === 'string' &&
-                typeof metadata.status === 'string' &&
-                Array.isArray(_observations);
-            if (!message.observations.length && !cellEnvelope)
-                return undefined;
-            if (cellEnvelope) {
-                // Keep execution facts in storage; project only actionable lifecycle metadata.
-                delete metadata.toolCalls;
-                delete metadata.outputBytes;
-                if (metadata.outputDroppedBytes === 0)
-                    delete metadata.outputDroppedBytes;
-                if (metadata.truncated === false)
-                    delete metadata.truncated;
-                if (metadata.cached === false)
-                    delete metadata.cached;
-            }
-            prefix.push({ type: 'text', text: JSON.stringify(metadata) });
-        }
-    }
-    catch {
-        // Malformed envelope metadata must not hide structured observations.
-    }
-    if (!message.observations.length && !prefix.length)
-        return undefined;
-    return [
-        ...prefix,
-        ...message.observations.flatMap((value) => {
-            const parts = [{ type: 'text', text: visibleObservationText(value) }];
-            for (const index of observationImages(value)) {
-                const image = message.images?.[index];
-                if (image)
-                    parts.push({ type: 'image', image });
-            }
-            return parts;
-        })
-    ];
-}
-/** Uses the same visible text as both adapters, without pixels or private observation data. */
-export function observationModelText(message) {
-    return observationModelParts(message)
-        ?.flatMap((part) => (part.type === 'text' ? [part.text] : []))
-        .join('\n');
-}
-export function parseObservations(value) {
-    if (!Array.isArray(value) || value.length > 4096)
-        return undefined;
-    const ids = new Set();
-    for (const item of value) {
-        if (!item || typeof item !== 'object' || typeof item.id !== 'string' || ids.has(item.id))
-            return undefined;
-        ids.add(item.id);
-        if (item.type === 'tool_result') {
-            if (!item.source ||
-                typeof item.source.callId !== 'string' ||
-                typeof item.source.toolName !== 'string' ||
-                !['completed', 'failed'].includes(item.outcome) ||
-                !item.result ||
-                typeof item.result.content !== 'string')
-                return undefined;
-        }
-        else if (item.type !== 'value' ||
-            !['text', 'json', 'image'].includes(item.format) ||
-            typeof item.value !== 'string')
-            return undefined;
-        const indices = item.type === 'tool_result' ? item.result.imageIndices : item.imageIndices;
-        if (indices !== undefined &&
-            (!Array.isArray(indices) ||
-                indices.some((i) => !Number.isSafeInteger(i) || Number(i) < 0 || Number(i) >= 5)))
-            return undefined;
-    }
-    return value;
-}

package/dist/agent-core/tools/code-mode/state.d.ts

@@ -1,9 +0,0 @@
-import type { CodeModeStateEntry, CodeModeStateMutation } from '../contracts.js';
-export type { CodeModeStateEntry, CodeModeStateMutation } from '../contracts.js';
-type StateRecord = {
-    readonly type: string;
-    readonly payload: unknown;
-};
-export declare function parseCodeModeStateMutations(value: unknown): CodeModeStateMutation[];
-export declare function restoreCodeModeState(records: readonly StateRecord[], initialState?: CodeModeStateEntry[]): CodeModeStateEntry[];
-export declare function applyCodeModeStateMutations(entries: readonly CodeModeStateEntry[], mutations: readonly CodeModeStateMutation[]): CodeModeStateEntry[];

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

@@ -1,82 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
-export function parseCodeModeStateMutations(value) {
-    if (!Array.isArray(value) || value.length > limits.codeStateMaxMutations)
-        throw invalidState();
-    return value.map((item) => {
-        if (!isObject(item) || !validKey(item.key))
-            throw invalidState();
-        if (item.operation === 'delete' &&
-            Object.keys(item).every((key) => ['operation', 'key'].includes(key)))
-            return { operation: 'delete', key: item.key };
-        if (item.operation === 'set' &&
-            Object.keys(item).every((key) => ['operation', 'key', 'value'].includes(key)) &&
-            Object.prototype.hasOwnProperty.call(item, 'value'))
-            return { operation: 'set', key: item.key, value: cloneStateValue(item.value) };
-        throw invalidState();
-    });
-}
-export function restoreCodeModeState(records, initialState = []) {
-    let state = initialState;
-    for (const record of records) {
-        if (record.type !== 'code.state.updated')
-            continue;
-        if (!isObject(record.payload) ||
-            !Object.keys(record.payload).every((key) => key === 'mutations'))
-            throw corruptState();
-        let mutations;
-        try {
-            mutations = parseCodeModeStateMutations(record.payload.mutations);
-            state = applyCodeModeStateMutations(state, mutations);
-        }
-        catch (error) {
-            if (error instanceof MarAgentError)
-                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Code Mode state is corrupt.', {
-                    cause: error
-                });
-            throw error;
-        }
-    }
-    return state;
-}
-export function applyCodeModeStateMutations(entries, mutations) {
-    const state = new Map(entries.map((entry) => [entry.key, cloneStateValue(entry.value)]));
-    for (const mutation of mutations) {
-        if (mutation.operation === 'delete')
-            state.delete(mutation.key);
-        else
-            state.set(mutation.key, cloneStateValue(mutation.value));
-    }
-    if (state.size > limits.codeStateMaxEntries)
-        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state has too many entries.');
-    const result = [...state].map(([key, value]) => ({ key, value }));
-    if (Buffer.byteLength(JSON.stringify(result)) > limits.codeStateMaxTotalBytes)
-        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state is too large.');
-    return result;
-}
-function validKey(value) {
-    return (typeof value === 'string' &&
-        value.length > 0 &&
-        Buffer.byteLength(value) <= limits.codeStateMaxKeyBytes);
-}
-function cloneStateValue(value) {
-    let serialized;
-    try {
-        serialized = JSON.stringify(value);
-    }
-    catch {
-        throw invalidState();
-    }
-    if (serialized === undefined || Buffer.byteLength(serialized) > limits.codeStateMaxValueBytes)
-        throw invalidState();
-    return JSON.parse(serialized);
-}
-function invalidState() {
-    return new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode state mutation is invalid.');
-}
-function corruptState() {
-    return new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Code Mode state is corrupt.');
-}
-function isObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}

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

@@ -1,211 +0,0 @@
-import type { ExecutionMode } from '../runtime/contracts.js';
-export type ToolCaller = 'direct' | 'programmatic';
-export interface ClientToolDefinition {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    /** Runtime-only provider lowering hint; unsupported adapters fall back to a normal function tool. */
-    nativeType?: 'tool_search';
-    /** Runtime-only result contract; never forwarded as an upstream tool field. */
-    outputSchema?: Record<string, unknown>;
-    /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
-    allowedCallers?: readonly ToolCaller[];
-    /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
-    codeModeExposure?: 'both';
-    inputMode?: 'json' | 'freeform';
-    parallelSafety?: 'safe' | 'serial';
-    /** Preserved business-schema eligibility after framework metadata projection. */
-    parameterless?: boolean;
-    /** Runtime-only Agent catalog scope; never forwarded as an upstream tool field. */
-    agentScope?: 'ROOT_AND_SUBAGENTS' | 'ROOT_ONLY';
-}
-export interface ToolCall {
-    name: string;
-    arguments: unknown;
-    callId?: string;
-    /** Framework metadata for native invocations, never a business argument. */
-    permission?: import('./permissions.js').ToolPermission | null;
-}
-export interface ToolExecutionContext {
-    mode: ExecutionMode;
-    signal: AbortSignal;
-    waitInterrupt?: import('./wait.js').ToolWaitInterrupt | undefined;
-    /** Live-only process output; does not consume the eventual tool result. */
-    onOutput?: (output: ExecOutputSnapshot) => Promise<void>;
-    sessionId: string;
-    executionId: string;
-    /** Current model identity for neutral Host-owned tool policies. */
-    modelId?: string;
-    recentImages?: readonly {
-        readonly mimeType: string;
-        readonly data: Buffer;
-    }[];
-    codeMode?: {
-        retainSession?(): Promise<() => Promise<void>>;
-        onSettled?(result: CodeCellEventData): Promise<void>;
-        supportsImages?: boolean;
-        permissionStop?(): import('./permissions.js').PermissionStop | undefined;
-        tools: readonly ClientToolDefinition[];
-        state?: readonly CodeModeStateEntry[];
-        commitState?(mutations: readonly CodeModeStateMutation[]): Promise<readonly CodeModeStateEntry[]>;
-        invoke(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
-    };
-}
-export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId' | 'modelId'> {
-    executionScopeId?: string;
-    claimExecutionScope?: boolean;
-}
-export interface McpToolCatalog {
-    readonly revision: string;
-    readonly servers: readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly description?: string;
-        readonly instructions?: string;
-    }[];
-    readonly tools: readonly McpCatalogTool[];
-}
-export interface McpCatalogTool {
-    readonly definition: ClientToolDefinition;
-    readonly serverId: string;
-    readonly rawName: string;
-    readonly sourceIdentity: string;
-    readonly definitionRevision: string;
-    readonly lifetime: 'session' | 'execution';
-    readonly exposure: 'direct' | 'deferred';
-    /** Untrusted MCP hints; never an authorization or parallel-safety decision. */
-    readonly annotations?: Readonly<Record<string, unknown>>;
-}
-export interface McpToolCallContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
-    readonly mode?: ExecutionMode;
-    readonly expectedTool?: {
-        readonly sourceIdentity: string;
-        readonly definitionRevision: string;
-    };
-}
-export interface MarAgentToolImageArtifact {
-    kind: 'image';
-    name: string;
-    mimeType: 'image/png';
-    byteSize: number;
-    sha256: string;
-    fileName: string;
-}
-export type MarAgentToolArtifact = MarAgentToolImageArtifact;
-export interface ExecOutputSnapshot {
-    processId: string;
-    stdout: string;
-    stderr: string;
-    truncated: boolean;
-}
-export interface ToolExecutionResult {
-    calls?: readonly import('./code-mode/observations.js').CodeToolCallRecord[];
-    content: string;
-    observations?: readonly import('./code-mode/observations.js').CodeObservation[];
-    data?: unknown;
-    /** Runtime-only definitions used to encode a Tool Search output. */
-    toolSearchTools?: readonly ClientToolDefinition[];
-    truncated?: boolean;
-    images?: readonly import('../model/image.js').ModelImage[];
-    artifacts?: readonly MarAgentToolArtifact[];
-    /** Host-facing evidence, excluded from model and programmatic guest results. */
-    resultExtensions?: readonly import('./result-extensions.js').ToolResultExtension[];
-}
-export interface CodeCellEventData {
-    permissionStop?: import('./permissions.js').PermissionStop;
-    calls?: readonly import('./code-mode/observations.js').CodeToolCallRecord[];
-    cellId: string;
-    status: 'running' | 'completed' | 'failed' | 'cancelled';
-    waitOutcome?: import('./wait.js').ToolWaitOutcome;
-    reason?: 'steer';
-    cached?: boolean;
-    observations?: readonly import('./code-mode/observations.js').CodeObservation[];
-}
-export interface ExecResult {
-    status: 'running' | 'completed' | 'cancelled';
-    waitOutcome?: import('./wait.js').ToolWaitOutcome;
-    reason?: 'steer';
-    processId?: string;
-    stdout: string;
-    stderr: string;
-    exitCode?: number | null;
-    truncated: boolean;
-    stdoutBytes: number;
-    stderrBytes: number;
-    stdoutDroppedBytes: number;
-    stderrDroppedBytes: number;
-    /** A terminal snapshot replay rather than new process output. */
-    cached?: boolean;
-}
-export interface ApplyPatchFileResult {
-    path: string;
-    targetPath?: string;
-    operation: 'added' | 'modified' | 'deleted' | 'moved';
-    addedLines: number;
-    deletedLines: number;
-}
-export interface ApplyPatchResult {
-    files: ApplyPatchFileResult[];
-    totals: {
-        files: number;
-        addedLines: number;
-        deletedLines: number;
-    };
-}
-export interface ApplyPatchPartialResult extends ApplyPatchResult {
-    failedFile: string;
-    pendingFiles: string[];
-}
-export interface ReadEventData {
-    mode: 'batch';
-    results: Array<{
-        path: string;
-        startLine?: number;
-        endLine?: number;
-        error?: {
-            code: string;
-            message: string;
-        };
-    }>;
-    truncated: boolean;
-}
-export interface ViewImageRegion {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export interface ViewImageResult {
-    /** The input source; transformations may produce a different output resource. */
-    path?: string;
-    resourceId?: string;
-    mimeType: 'image/png' | 'image/jpeg' | 'image/webp';
-    bytes: number;
-    width: number;
-    height: number;
-    sourceWidth?: number;
-    sourceHeight?: number;
-    region?: ViewImageRegion;
-    sha256: string;
-}
-export interface TodoItem {
-    id: string;
-    step: string;
-    status: 'pending' | 'in_progress' | 'completed';
-}
-export interface TodoSnapshot {
-    revision: number;
-    items: TodoItem[];
-}
-export interface CodeModeStateEntry {
-    readonly key: string;
-    readonly value: unknown;
-}
-export type CodeModeStateMutation = {
-    readonly operation: 'set';
-    readonly key: string;
-    readonly value: unknown;
-} | {
-    readonly operation: 'delete';
-    readonly key: string;
-};

package/dist/agent-core/tools/definition-projection.d.ts

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from './contracts.js';
-/** Stable model declarations, not a serializer for historical messages or tool results. */
-export declare function stableToolSchema<T>(schema: T): T;
-export declare function stableToolDefinition(definition: ClientToolDefinition): ClientToolDefinition;
-export declare function orderToolDefinitions<T extends {
-    readonly name: string;
-}>(definitions: readonly T[]): T[];

package/dist/agent-core/tools/definition-projection.js

@@ -1,26 +0,0 @@
-/** Stable model declarations, not a serializer for historical messages or tool results. */
-export function stableToolSchema(schema) {
-    return stableSchemaValue(schema);
-}
-function stableSchemaValue(value) {
-    if (Array.isArray(value))
-        return value.map(stableSchemaValue);
-    if (value === null || typeof value !== 'object')
-        return value;
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null)
-        return value;
-    const fields = value;
-    return Object.fromEntries(Object.keys(fields)
-        .sort()
-        .map((key) => [key, stableSchemaValue(fields[key])]));
-}
-export function stableToolDefinition(definition) {
-    return {
-        ...definition,
-        inputSchema: stableToolSchema(definition.inputSchema)
-    };
-}
-export function orderToolDefinitions(definitions) {
-    return [...definitions].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
-}