@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/runtime/context/instructions.d.ts

@@ -1,37 +0,0 @@
-import type { HostSkill } from '../../host/contracts.js';
-export interface AgentInstructionEntry {
-    kind: 'user' | 'project' | 'scoped';
-    label: string;
-    sourcePath: string;
-    displayPath: string;
-    scopePath: string;
-    displayScope: string;
-    content: string;
-    truncated: boolean;
-}
-interface FileAgentSkill {
-    name: string;
-    description: string;
-    path: string;
-    displayPath: string;
-    boundary: string;
-    source?: 'file';
-}
-export type AgentSkill = FileAgentSkill | (HostSkill & {
-    source: 'host';
-});
-export declare function agentSkillSource(skill: AgentSkill): string;
-export declare function loadAgentInstructions(input: {
-    home: string;
-    workspace: string;
-    workspaceDisplayPath?: string;
-    availableTools?: ReadonlySet<string>;
-    hostSkills?: readonly HostSkill[];
-}): Promise<{
-    entries: readonly AgentInstructionEntry[];
-    skillCatalog: string;
-    skills: ReadonlyMap<string, AgentSkill>;
-}>;
-export declare function renderAgentInstructions(entries: readonly AgentInstructionEntry[], previousMayContainInstructions: boolean): string | undefined;
-export declare function loadAgentSkill(skill: AgentSkill): Promise<string>;
-export {};

package/dist/agent-core/runtime/context/instructions.js

@@ -1,297 +0,0 @@
-import { markupAttributes, markupText } from '../../prompts/markup.js';
-import { open, readdir, realpath, stat } from 'node:fs/promises';
-import { dirname, isAbsolute, join, parse, posix, relative, resolve } from 'node:path';
-import { MarAgentError } from '../../error.js';
-const MAX_FILE_BYTES = 64 * 1024;
-const MAX_PROJECT_BYTES = 32 * 1024;
-const INSTRUCTION_FILENAMES = ['AGENTS.override.md', 'AGENTS.md'];
-const REPLACEMENT_NOTICE = 'These AGENTS.md instructions replace all previously provided AGENTS.md instructions.';
-const REMOVAL_NOTICE = 'The previously provided AGENTS.md instructions no longer apply.';
-export function agentSkillSource(skill) {
-    return skill.source === 'host' ? 'Host-provided' : dirname(skill.displayPath);
-}
-export async function loadAgentInstructions(input) {
-    const entries = [];
-    let remaining = MAX_PROJECT_BYTES;
-    const addPreferred = async (entry) => {
-        const maxBytes = entry.kind === 'user' ? MAX_FILE_BYTES : remaining;
-        if (maxBytes === 0)
-            return;
-        const selected = await loadPreferredInstruction({
-            directory: entry.directory,
-            boundary: entry.boundary,
-            maxBytes
-        });
-        if (!selected || !selected.content.trim())
-            return;
-        entries.push({
-            kind: entry.kind,
-            label: selected.override ? `${entry.label} (override)` : entry.label,
-            sourcePath: selected.sourcePath,
-            displayPath: displayJoin(entry.displayDirectory, selected.fileName),
-            scopePath: resolve(entry.scopePath),
-            displayScope: entry.displayScope,
-            content: selected.content,
-            truncated: selected.truncated
-        });
-        if (entry.kind !== 'user')
-            remaining -= selected.loadedBytes;
-    };
-    await addPreferred({
-        kind: 'user',
-        label: 'User instructions',
-        directory: join(input.home, '.agents'),
-        boundary: input.home,
-        displayDirectory: '~/.agents',
-        displayScope: '<account>',
-        scopePath: input.home
-    });
-    const projectRoot = await nearestProjectRoot(input.workspace);
-    await addPreferred({
-        kind: 'project',
-        label: 'Project instructions',
-        directory: projectRoot,
-        boundary: projectRoot,
-        displayDirectory: '<project>',
-        displayScope: '<project>',
-        scopePath: projectRoot
-    });
-    for (const directory of instructionDirectories(projectRoot, input.workspace).slice(1)) {
-        const relativeDirectory = relative(projectRoot, directory);
-        const displayDirectory = projectDisplayPath(projectRoot, directory);
-        await addPreferred({
-            kind: 'scoped',
-            label: `Scoped instructions: ${relativeDirectory}`,
-            directory,
-            boundary: projectRoot,
-            displayDirectory,
-            displayScope: displayDirectory,
-            scopePath: directory
-        });
-    }
-    const skills = new Map();
-    const hostNames = new Set();
-    for (const skill of input.hostSkills ?? []) {
-        if (!skill.name.trim() || skill.name.length > 128 || hostNames.has(skill.name))
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host skill names must be unique and nonempty.');
-        hostNames.add(skill.name);
-        if (skill.requiredTools.every((name) => input.availableTools?.has(name)))
-            skills.set(skill.name, { ...skill, source: 'host', load: () => skill.load() });
-    }
-    await discoverSkills(join(input.home, '.agents', 'skills'), input.home, skills);
-    const projectSkillRoot = join(projectRoot, '.agents', 'skills');
-    await discoverSkills(projectSkillRoot, projectRoot, skills, displayPath(projectSkillRoot, input.workspace, input.workspaceDisplayPath));
-    const skillCatalog = skills.size === 0
-        ? ''
-        : `## Available skills\n\n${[...skills]
-            .map(([name, skill]) => `- ${name}: ${skill.description} (source: ${agentSkillSource(skill)})`)
-            .join('\n')}`;
-    return { entries, skillCatalog, skills };
-}
-export function renderAgentInstructions(entries, previousMayContainInstructions) {
-    if (entries.length === 0 && !previousMayContainInstructions)
-        return undefined;
-    const notice = entries.length === 0
-        ? REMOVAL_NOTICE
-        : previousMayContainInstructions
-            ? REPLACEMENT_NOTICE
-            : '';
-    const sections = entries.map((entry) => [
-        `## ${entry.label}`,
-        `Source: ${entry.displayPath}`,
-        `Scope: ${entry.displayScope}`,
-        ...(entry.truncated ? ['Status: truncated to the configured instruction budget'] : []),
-        '',
-        entry.content
-    ].join('\n'));
-    return [
-        '# AGENTS.md instructions',
-        '',
-        markupText('mar_instructions', [notice, ...sections].filter(Boolean).join('\n'))
-    ].join('\n');
-}
-export async function loadAgentSkill(skill) {
-    if (skill.source === 'host') {
-        const body = await skill.load();
-        if (!body.trim() || Buffer.byteLength(body) > MAX_FILE_BYTES)
-            return '';
-        return [
-            `<mar_skill${markupAttributes({ name: skill.name, source: agentSkillSource(skill) })}>`,
-            '  ' +
-                markupText('instruction', 'This skill has no filesystem base directory or bundled scripts.'),
-            '  ' + markupText('content', body.trim()),
-            '</mar_skill>'
-        ].join('\n');
-    }
-    const body = await safeRead(skill.path, skill.boundary);
-    if (!body)
-        return '';
-    const base = dirname(skill.path);
-    const displayBase = dirname(skill.displayPath);
-    const files = await sampleSkillFiles(base);
-    return [
-        `<mar_skill${markupAttributes({ name: skill.name, source: agentSkillSource(skill), baseDirectory: displayBase })}>`,
-        '  ' +
-            markupText('instruction', 'Relative paths in this skill are relative to the base directory. The file list is a sample; read only resources needed for the task.'),
-        '  ' + markupText('content', body.trim()),
-        ...files.map((path) => `  <file${markupAttributes({ path: displayDescendant(base, displayBase, path) })} />`),
-        '</mar_skill>'
-    ].join('\n');
-}
-async function nearestProjectRoot(workspace) {
-    let current = resolve(workspace);
-    const root = parse(current).root;
-    while (true) {
-        try {
-            await stat(join(current, '.git'));
-            return current;
-        }
-        catch {
-            if (current === root)
-                return resolve(workspace);
-            current = dirname(current);
-        }
-    }
-}
-function instructionDirectories(root, target) {
-    const relativeTarget = relative(root, resolve(target));
-    if (relativeTarget.startsWith('..') || isAbsolute(relativeTarget))
-        return [resolve(target)];
-    const result = [root];
-    let current = root;
-    for (const part of relativeTarget.split(/[\\/]/u).filter(Boolean)) {
-        current = join(current, part);
-        result.push(current);
-    }
-    return result;
-}
-async function discoverSkills(root, boundary, target, displayRoot = root) {
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory() && !entry.isSymbolicLink())
-            continue;
-        const path = join(root, entry.name, 'SKILL.md');
-        const content = await safeRead(path, boundary);
-        if (!content)
-            continue;
-        const description = /^description:\s*(.+)$/imu.exec(content)?.[1]?.trim() ?? 'Agent skill';
-        target.set(entry.name, {
-            name: entry.name,
-            description,
-            path,
-            displayPath: displayJoin(displayRoot, entry.name, 'SKILL.md'),
-            boundary
-        });
-    }
-}
-async function safeRead(path, boundary) {
-    try {
-        const [resolvedPath, resolvedBoundary] = await Promise.all([
-            realpath(path),
-            realpath(boundary)
-        ]);
-        const rel = relative(resolvedBoundary, resolvedPath);
-        if (rel.startsWith('..') || isAbsolute(rel))
-            return undefined;
-        const loaded = await readInstructionFile(resolvedPath, MAX_FILE_BYTES);
-        return loaded && !loaded.truncated ? loaded.content : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function loadPreferredInstruction(input) {
-    for (const fileName of INSTRUCTION_FILENAMES) {
-        const sourcePath = resolve(input.directory, fileName);
-        const loaded = await readInstructionFile(sourcePath, input.maxBytes);
-        if (!loaded)
-            continue;
-        return {
-            sourcePath,
-            fileName,
-            override: fileName === 'AGENTS.override.md',
-            ...loaded
-        };
-    }
-    return undefined;
-}
-async function readInstructionFile(path, maxBytes) {
-    let handle;
-    try {
-        if (!(await stat(path)).isFile())
-            return undefined;
-        handle = await open(path, 'r');
-        const buffer = Buffer.allocUnsafe(maxBytes + 1);
-        let readBytes = 0;
-        while (readBytes < buffer.length) {
-            const { bytesRead } = await handle.read(buffer, readBytes, buffer.length - readBytes, readBytes);
-            if (bytesRead === 0)
-                break;
-            readBytes += bytesRead;
-        }
-        const loadedBytes = Math.min(readBytes, maxBytes);
-        return {
-            content: buffer.subarray(0, loadedBytes).toString('utf8'),
-            loadedBytes,
-            truncated: readBytes > loadedBytes
-        };
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-    }
-}
-function projectDisplayPath(projectRoot, directory) {
-    const suffix = relative(resolve(projectRoot), resolve(directory));
-    return displayJoin('<project>', ...suffix.split(/[\\/]/u).filter(Boolean));
-}
-async function sampleSkillFiles(root) {
-    const files = [];
-    const directories = [root];
-    let scannedDirectories = 0;
-    while (directories.length > 0 && files.length < 10 && scannedDirectories < 128) {
-        const directory = directories.shift();
-        scannedDirectories++;
-        let entries;
-        try {
-            entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (entry.isSymbolicLink())
-                continue;
-            const path = join(directory, entry.name);
-            if (entry.isDirectory())
-                directories.push(path);
-            else if (entry.isFile() && path !== join(root, 'SKILL.md'))
-                files.push(path);
-            if (files.length >= 10)
-                break;
-        }
-    }
-    return files;
-}
-function displayPath(path, physicalWorkspace, logicalWorkspace) {
-    if (logicalWorkspace === undefined)
-        return path;
-    const suffix = relative(resolve(physicalWorkspace), resolve(path));
-    if (suffix.startsWith('..') || isAbsolute(suffix))
-        return path;
-    return displayJoin(logicalWorkspace, ...suffix.split(/[\\/]/u).filter(Boolean));
-}
-function displayDescendant(physicalRoot, displayRoot, path) {
-    return displayJoin(displayRoot, ...relative(physicalRoot, path).split(/[\\/]/u).filter(Boolean));
-}
-function displayJoin(root, ...parts) {
-    return root.startsWith('/') ? posix.join(root, ...parts) : join(root, ...parts);
-}

package/dist/agent-core/runtime/context/normalize.d.ts

@@ -1,5 +0,0 @@
-import type { ModelMessage } from '../../model/contracts.js';
-export interface NormalizeModelContextInput {
-    supportsImages: boolean;
-}
-export declare function normalizeMessagesForModel(messages: readonly ModelMessage[], input: NormalizeModelContextInput): ModelMessage[];

package/dist/agent-core/runtime/context/projection.d.ts

@@ -1,23 +0,0 @@
-import type { ModelMessage } from '../../model/contracts.js';
-import { type ContextGcCheckpointCache, type ContextGcCheckpointPayload, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
-import type { SessionRecord } from '../../session/store/index.js';
-export interface ContextProjectionEntry {
-    readonly record: SessionRecord;
-    readonly message: ModelMessage;
-}
-export interface ContextProjection {
-    readonly entries: readonly ContextProjectionEntry[];
-    readonly checkpoint?: ContextGcCheckpointPayload;
-}
-export declare function buildContextProjection(records: readonly SessionRecord[], checkpointCache?: ContextGcCheckpointCache): ContextProjection;
-export declare function applyContextGcReplacementsToMessages(messages: readonly ModelMessage[], messageSources: readonly SessionRecord[], replacements: readonly ContextGcReplacement[]): {
-    readonly messages: ModelMessage[];
-    readonly messageSources: SessionRecord[];
-};
-export declare function filterPairedContext(messages: readonly ModelMessage[], messageSources: readonly SessionRecord[]): {
-    readonly messages: ModelMessage[];
-    readonly messageSources: SessionRecord[];
-};
-export declare function restoreModelContext(payload: Record<string, unknown>, providerModelId?: string): ModelMessage | undefined;
-export declare function providerToolCallId(message: ModelMessage): string | undefined;
-export declare function providerToolName(message: ModelMessage): string | undefined;

package/dist/agent-core/runtime/context/projection.js

@@ -1,284 +0,0 @@
-import { restoreNativeModelContext } from '../../model/native-context.js';
-import { appliedInputRecord } from '../../session/deferred-input.js';
-import { inputMetadataFromRecord } from '../../session/store/execution-state.js';
-import { parseModelImages } from '../../model/image.js';
-import { contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
-import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
-import { replaceReadContextItems } from '../../tools/local/read-context.js';
-import { parseCodeCalls, parseObservations, renderObservationResult } from '../../tools/code-mode/observations.js';
-const MAX_MODEL_CONTEXT_BYTES = 1024 * 1024;
-export function buildContextProjection(records, checkpointCache) {
-    let activeModelId;
-    const rawEntries = [];
-    for (const record of records) {
-        if (record.type === 'execution.header') {
-            activeModelId = modelIdFromPayload(record.payload);
-            continue;
-        }
-        if (record.type === 'compact.completed') {
-            activeModelId = modelIdFromPayload(record.payload);
-            rawEntries.splice(0);
-            continue;
-        }
-        if (record.type !== 'model.context' || !isRecord(record.payload))
-            continue;
-        const applied = appliedInputRecord(record);
-        const message = applied
-            ? {
-                role: 'user',
-                content: record.payload.content,
-                metadata: inputMetadataFromRecord(applied)
-            }
-            : restoreModelContext(record.payload, activeModelId);
-        if (message)
-            rawEntries.push({ record, message });
-    }
-    const valid = checkpointCache
-        ? checkpointCache.read(records)
-        : latestValidContextGcCheckpoint(records);
-    const messages = rawEntries.flatMap((entry) => (entry.message ? [entry.message] : []));
-    const sources = rawEntries.flatMap((entry) => (entry.message ? [entry.record] : []));
-    const applied = applyContextGcReplacementsToMessages(messages, sources, valid?.payload.replacements ?? []);
-    const paired = filterPairedContext(applied.messages, applied.messageSources);
-    const entries = paired.messages.map((message, index) => ({
-        message,
-        record: paired.messageSources[index]
-    }));
-    return { entries, ...(valid ? { checkpoint: valid.payload } : {}) };
-}
-export function applyContextGcReplacementsToMessages(messages, messageSources, replacements) {
-    if (messages.length !== messageSources.length)
-        throw new Error('Context projection message sources are not aligned.');
-    const direct = new Map(replacements.map((replacement) => [contextGcTargetKey(replacement.target), replacement]));
-    const aliases = new Set(replacements.flatMap((replacement) => replacement.kind === 'TOOL_CALL_INPUT'
-        ? replacement.providerAliasTargets.map(contextGcTargetKey)
-        : []));
-    const projected = [];
-    for (const [index, source] of messageSources.entries()) {
-        const message = messages[index];
-        const target = targetFromMessage(source, message);
-        if (target && aliases.has(contextGcTargetKey(target)))
-            continue;
-        const replacement = target ? direct.get(contextGcTargetKey(target)) : undefined;
-        let next = cloneMessage(message);
-        if (next.observations && target) {
-            const observations = next.observations.map((value) => {
-                const itemTarget = { ...target, observationId: value.id };
-                const item = direct.get(contextGcTargetKey(itemTarget));
-                if (!item || !targetMatchesReplacement(itemTarget, item.target))
-                    return value;
-                if (item.kind === 'READ_OUTPUT_ITEMS' && value.type === 'tool_result')
-                    return {
-                        ...value,
-                        result: {
-                            ...value.result,
-                            content: replaceReadContextItems(value.result.content, item.items)
-                        }
-                    };
-                if ('replacementContent' in item)
-                    return value.type === 'tool_result'
-                        ? { ...value, result: { ...value.result, content: item.replacementContent } }
-                        : { ...value, value: item.replacementContent };
-                return value;
-            });
-            next = {
-                ...next,
-                observations,
-                content: next.textBlocks === undefined
-                    ? renderObservationResult(observations, next.content)
-                    : next.content
-            };
-        }
-        if (replacement && target && targetMatchesReplacement(target, replacement.target)) {
-            if (replacement.kind === 'READ_OUTPUT_ITEMS' &&
-                next.role === 'tool' &&
-                typeof next.content === 'string')
-                next = {
-                    ...next,
-                    content: replaceReadContextItems(next.content, replacement.items)
-                };
-            else if (replacement.kind === 'TOOL_CALL_INPUT' && next.role === 'tool_call')
-                next = { ...next, arguments: structuredClone(replacement.replacementArguments) };
-            else if ((replacement.kind === 'EXEC_OUTPUT' ||
-                replacement.kind === 'CODE_MODE_OUTPUT' ||
-                replacement.kind === 'SUBAGENT_OUTPUT' ||
-                replacement.kind === 'WEB_OUTPUT') &&
-                next.role === 'tool')
-                next = { ...next, content: replacement.replacementContent };
-        }
-        if (next.textBlocks !== undefined && next.content !== message.content)
-            next = {
-                ...next,
-                textBlocks: [{ text: next.content }]
-            };
-        projected.push({ message: next, source });
-    }
-    return {
-        messages: projected.map(({ message }) => message),
-        messageSources: projected.map(({ source }) => source)
-    };
-}
-export function filterPairedContext(messages, messageSources) {
-    if (messages.length !== messageSources.length)
-        throw new Error('Context projection message sources are not aligned.');
-    const entries = messages.map((message, index) => ({
-        message,
-        source: messageSources[index]
-    }));
-    const completedToolCalls = new Set(entries
-        .filter(({ message }) => message.role === 'tool')
-        .map(({ message }) => message.callId)
-        .filter((callId) => callId !== undefined));
-    const paired = entries.filter(({ message }) => {
-        if (message.role === 'tool_call')
-            return completedToolCalls.has(message.callId ?? '');
-        if (message.role !== 'provider' || message.provider !== 'OPENAI_RESPONSES')
-            return true;
-        const callId = providerToolCallId(message);
-        return callId === undefined || completedToolCalls.has(callId);
-    });
-    return {
-        messages: paired.map(({ message }) => message),
-        messageSources: paired.map(({ source }) => source)
-    };
-}
-export function restoreModelContext(payload, providerModelId) {
-    if (payload.inputRef !== undefined) {
-        const input = appliedInputRecord({ type: 'model.context', payload });
-        return {
-            role: 'user',
-            content: payload.content,
-            metadata: inputMetadataFromRecord(input)
-        };
-    }
-    const nativeItem = payload.role === 'provider' && payload.provider === 'OPENAI_RESPONSES' && isRecord(payload.item)
-        ? payload.item
-        : undefined;
-    const toolName = payload.role === 'tool_call'
-        ? payload.name
-        : nativeItem?.type === 'custom_tool_call'
-            ? nativeItem.name
-            : undefined;
-    const inputLimit = toolName === 'code_exec' || toolName === 'code_exec_wait'
-        ? TOOL_EXECUTION_LIMITS.codeMaxInputBytes
-        : toolName === 'apply_patch'
-            ? TOOL_EXECUTION_LIMITS.patchMaxBytes
-            : undefined;
-    const byteLimit = inputLimit === undefined ? MAX_MODEL_CONTEXT_BYTES : inputLimit * 6 + 4096;
-    if (Buffer.byteLength(JSON.stringify(payload)) > byteLimit)
-        return undefined;
-    if (payload.role === 'user' && typeof payload.content === 'string') {
-        const blocks = payload.textBlocks;
-        const textBlocks = Array.isArray(blocks) &&
-            Array.from(blocks).every((block) => block && typeof block.text === 'string') &&
-            blocks.map((block) => block.text).join('') === payload.content
-            ? blocks.map((block) => ({ text: block.text }))
-            : undefined;
-        return {
-            role: 'user',
-            content: payload.content,
-            contextKind: 'contextual',
-            ...(textBlocks === undefined ? {} : { textBlocks })
-        };
-    }
-    if (payload.role === 'tool' &&
-        typeof payload.content === 'string' &&
-        typeof payload.callId === 'string')
-        return {
-            role: 'tool',
-            content: payload.content,
-            callId: payload.callId,
-            ...(parseModelImages(payload.images)?.length
-                ? { images: parseModelImages(payload.images) }
-                : {}),
-            ...(typeof payload.name === 'string' ? { name: payload.name } : {}),
-            ...(typeof payload.isError === 'boolean' ? { isError: payload.isError } : {}),
-            ...(Array.isArray(payload.textBlocks) &&
-                payload.textBlocks.every((block) => block &&
-                    typeof block.text === 'string' &&
-                    (block.cache === undefined || block.cache === true)) &&
-                payload.textBlocks.map((block) => block.text).join('') === payload.content
-                ? {
-                    textBlocks: payload.textBlocks.map((block) => ({
-                        text: block.text,
-                        ...(block.cache === true ? { cache: true } : {})
-                    }))
-                }
-                : {}),
-            ...(parseCodeCalls(payload.calls) ? { calls: parseCodeCalls(payload.calls) } : {}),
-            ...(parseObservations(payload.observations)
-                ? { observations: parseObservations(payload.observations) }
-                : {}),
-            ...(Array.isArray(payload.toolSearchTools)
-                ? {
-                    toolSearchTools: payload.toolSearchTools.filter((tool) => isRecord(tool) &&
-                        typeof tool.name === 'string' &&
-                        typeof tool.description === 'string' &&
-                        isRecord(tool.inputSchema))
-                }
-                : {})
-        };
-    if (payload.role === 'tool_call' &&
-        typeof payload.callId === 'string' &&
-        typeof payload.name === 'string')
-        return {
-            role: 'tool_call',
-            content: '',
-            callId: payload.callId,
-            name: payload.name,
-            arguments: payload.arguments,
-            ...(payload.inputMode === 'json' || payload.inputMode === 'freeform'
-                ? { inputMode: payload.inputMode }
-                : {})
-        };
-    if (payload.role === 'provider')
-        return restoreNativeModelContext(payload, providerModelId);
-    return undefined;
-}
-export function providerToolCallId(message) {
-    if (message.role !== 'provider' || message.provider !== 'OPENAI_RESPONSES' || !message.item)
-        return undefined;
-    if (message.item.type !== 'function_call' &&
-        message.item.type !== 'custom_tool_call' &&
-        message.item.type !== 'tool_search_call')
-        return undefined;
-    return typeof message.item.call_id === 'string' ? message.item.call_id : undefined;
-}
-export function providerToolName(message) {
-    if (message.role !== 'provider' || !message.item)
-        return undefined;
-    if (message.item.type === 'tool_search_call')
-        return 'tool_search';
-    return typeof message.item.name === 'string' ? message.item.name : undefined;
-}
-function targetFromMessage(record, message) {
-    if (record.type !== 'model.context')
-        return undefined;
-    const callId = message.role === 'provider' ? providerToolCallId(message) : message.callId;
-    const toolName = message.role === 'provider' ? providerToolName(message) : message.name;
-    if (message.role !== 'tool_call' && message.role !== 'tool' && message.role !== 'provider')
-        return undefined;
-    return {
-        sequence: record.sequence,
-        recordId: record.recordId,
-        role: message.role,
-        ...(callId === undefined ? {} : { callId }),
-        ...(toolName === undefined ? {} : { toolName })
-    };
-}
-function targetMatchesReplacement(left, right) {
-    return (contextGcTargetKey(left) === contextGcTargetKey(right) &&
-        (right.toolName === undefined || right.toolName === left.toolName));
-}
-function cloneMessage(message) {
-    return structuredClone(message);
-}
-function modelIdFromPayload(payload, key = 'modelId') {
-    if (!isRecord(payload))
-        return undefined;
-    const value = payload[key];
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}

package/dist/agent-core/runtime/context/request-budget.d.ts

@@ -1,4 +0,0 @@
-import type { ClientToolDefinition, ModelMessage } from '../../model/contracts.js';
-import type { ModelImage } from '../../model/image.js';
-export declare function estimatedRequestTokens(system: string, messages: readonly ModelMessage[], tools: readonly ClientToolDefinition[], images?: readonly ModelImage[]): number;
-export declare function stableJson(value: unknown): string;

package/dist/agent-core/runtime/context/request-budget.js

@@ -1,25 +0,0 @@
-import { AGENT_EXECUTION_POLICY } from '../execution-policy.js';
-import { countModelTokens } from '../token-budget.js';
-import { observationModelText } from '../../tools/code-mode/observations.js';
-export function estimatedRequestTokens(system, messages, tools, images) {
-    const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
-    const textMessages = messages.map((message) => {
-        const { images: _images, observations: _observations, observationId: _observationId, metadata: _metadata, contextKind: _contextKind, contextualBlock: _contextualBlock, ...textMessage } = message;
-        const content = message.role === 'tool' ? observationModelText(message) : undefined;
-        if (content !== undefined)
-            textMessage.content = content;
-        return textMessage;
-    });
-    return (countModelTokens(`${system}${stableJson(textMessages)}${stableJson(tools)}`) +
-        transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
-}
-export function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(',')}]`;
-    if (value !== null && typeof value === 'object')
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
-            .join(',')}}`;
-    return JSON.stringify(value) ?? 'undefined';
-}