@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/runtime/execution.js

@@ -1,445 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { MarAgentError } from '../error.js';
-import { isProviderContextOverflow, recoverModelStream } from '../model/recovery.js';
-import { modelStreamEventObservedAt } from '../model/sse.js';
-import { modelOutputContinuationMessage } from '../prompts/output.js';
-import { executeRoundTools } from '../tools/execution.js';
-import { publicHostedToolEvents, publicModelUsage } from './event-projection.js';
-import { PlanOutputPrefix, splitPlanOutput } from './plan-output.js';
-import { ModelGenerationTiming } from './model-generation-timing.js';
-/** Own the single model/tool loop; the SDK owns its handle, terminal events and cleanup. */
-export class ExecutionLoop {
-    input;
-    #finalAnswer = '';
-    planOutputPrefixes = new Map();
-    get finalAnswer() {
-        return this.#finalAnswer;
-    }
-    set finalAnswer(value) {
-        this.#finalAnswer = value;
-    }
-    constructor(input) {
-        this.input = input;
-    }
-    async run() {
-        const input = this.input;
-        const { mode, messages } = input;
-        let recoveringFromContextOverflow = false;
-        let maxOutputContinuationUsed = false;
-        let pendingOutputContinuation;
-        const modelRetryState = { attempts: 0 };
-        while (true) {
-            let stop;
-            let sawTool = false;
-            let latestUsage;
-            let roundServerUsage;
-            const pendingTools = [];
-            let incompleteToolCall = false;
-            const round = await input.prepareRound(pendingOutputContinuation);
-            const reasoningScope = randomUUID();
-            const publishedReasoning = new Set();
-            const startedMessages = new Set();
-            const leadingMessageWhitespace = new Map();
-            let sawModelSemanticEvent = false;
-            let requestStartedAt;
-            let firstModelResponseAt;
-            let generation = new ModelGenerationTiming();
-            let requestCompletedAt;
-            let requestOutputTokens;
-            const roundMessageCount = messages.length;
-            const emitLatency = async () => {
-                if (mode === 'compact' || firstModelResponseAt === undefined)
-                    return;
-                await input.publish({
-                    type: 'model.performance',
-                    latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt))
-                });
-            };
-            const emitFinalPerformance = async (completedAt) => {
-                if (mode === 'compact')
-                    return;
-                generation.finish(completedAt);
-                const outputDuration = generation.durationMs;
-                const outputTokens = requestOutputTokens;
-                if (outputTokens === undefined || outputDuration === undefined)
-                    return;
-                await input.publish({
-                    type: 'model.performance',
-                    ...(firstModelResponseAt === undefined
-                        ? {}
-                        : { latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)) }),
-                    outputTokens,
-                    outputDurationMs: Math.round(outputDuration),
-                    tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
-                });
-            };
-            const persistToolCalls = async (calls) => {
-                for (const call of calls) {
-                    const message = {
-                        role: 'tool_call',
-                        callId: call.callId,
-                        name: call.name,
-                        arguments: call.arguments,
-                        ...(call.inputMode ? { inputMode: call.inputMode } : {}),
-                        content: ''
-                    };
-                    messages.push(message);
-                    await input.appendContext(message);
-                }
-            };
-            try {
-                requestStartedAt = performance.now();
-                for await (const event of input.startModel({
-                    ...round.request,
-                    retryState: modelRetryState
-                })) {
-                    if (event.type === 'output.reset') {
-                        generation = new ModelGenerationTiming();
-                        requestCompletedAt = undefined;
-                        requestOutputTokens = undefined;
-                        continue;
-                    }
-                    const observedAt = Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now());
-                    if (event.type === 'output.started') {
-                        generation.start(observedAt);
-                        continue;
-                    }
-                    if (event.type === 'output.completed') {
-                        generation.finish(observedAt);
-                        continue;
-                    }
-                    if (event.type === 'output.paused') {
-                        generation.pause(observedAt);
-                        continue;
-                    }
-                    const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? observedAt : undefined;
-                    const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
-                    if (modelResponseAt !== undefined) {
-                        if (event.type !== 'output.delta')
-                            sawModelSemanticEvent = true;
-                        firstModelResponseAt ??= modelResponseAt;
-                        if (event.type === 'output.delta' ||
-                            (event.type === 'text.delta' && event.delta.length > 0)) {
-                            generation.start(modelResponseAt);
-                        }
-                    }
-                    if (event.type === 'response.item') {
-                        // Compaction keeps only its successful checkpoint, never intermediate native output.
-                        if (mode === 'compact')
-                            continue;
-                        const message = {
-                            role: 'provider',
-                            content: '',
-                            provider: event.provider,
-                            providerModelId: input.model.id,
-                            ...(event.contextKind === undefined ? {} : { contextKind: event.contextKind }),
-                            item: event.item
-                        };
-                        messages.push(message);
-                        await input.appendContext(message);
-                    }
-                    else if (event.type === 'text.delta') {
-                        let delta = event.delta;
-                        if (mode === 'plan' && input.sourceType !== 'subagent') {
-                            let prefix = this.planOutputPrefixes.get(event.itemId);
-                            if (!prefix) {
-                                prefix = new PlanOutputPrefix();
-                                this.planOutputPrefixes.set(event.itemId, prefix);
-                            }
-                            delta = prefix.push(delta);
-                        }
-                        if (mode !== 'compact' && delta) {
-                            if (!startedMessages.has(event.itemId)) {
-                                delta = (leadingMessageWhitespace.get(event.itemId) ?? '') + delta;
-                                if (!delta.trim()) {
-                                    leadingMessageWhitespace.set(event.itemId, delta);
-                                    continue;
-                                }
-                                leadingMessageWhitespace.delete(event.itemId);
-                                startedMessages.add(event.itemId);
-                                await input.publish({
-                                    type: 'message.started',
-                                    itemId: event.itemId,
-                                    phase: event.phase
-                                });
-                            }
-                            await input.publish({
-                                type: 'message.delta',
-                                itemId: event.itemId,
-                                phase: event.phase,
-                                delta
-                            });
-                        }
-                    }
-                    else if (event.type === 'text.completed') {
-                        leadingMessageWhitespace.delete(event.itemId);
-                        const phase = event.phase ?? 'final_answer';
-                        if (phase === 'final_answer')
-                            this.finalAnswer = event.text;
-                        this.planOutputPrefixes.delete(event.itemId);
-                        if (mode !== 'compact') {
-                            if (mode === 'plan' && input.sourceType !== 'subagent') {
-                                const parts = splitPlanOutput(event.text);
-                                for (const [index, part] of parts.entries()) {
-                                    const itemId = index === 0 ? event.itemId : `${event.itemId}:plan-part:${index}`;
-                                    if (part.kind === 'plan')
-                                        await input.publish({ type: 'plan.completed', itemId, text: part.text });
-                                    else {
-                                        await input.publish({
-                                            type: 'message.completed',
-                                            itemId,
-                                            phase,
-                                            text: part.text,
-                                            modelId: input.model.id,
-                                            modelName: input.model.name
-                                        });
-                                    }
-                                }
-                            }
-                            else {
-                                await input.publish({
-                                    type: 'message.completed',
-                                    itemId: event.itemId,
-                                    phase,
-                                    text: event.text,
-                                    modelId: input.model.id,
-                                    modelName: input.model.name
-                                });
-                            }
-                        }
-                        messages.push({ role: 'assistant', content: event.text });
-                    }
-                    else if (event.type === 'usage') {
-                        latestUsage = event.usage;
-                        if (event.final === true)
-                            generation.finish(observedAt);
-                        const outputTokens = typeof event.usage.outputTokens === 'number' &&
-                            Number.isSafeInteger(event.usage.outputTokens) &&
-                            event.usage.outputTokens >= 0
-                            ? event.usage.outputTokens
-                            : undefined;
-                        if (event.final !== false && (outputTokens !== undefined || event.final === true))
-                            requestOutputTokens = outputTokens;
-                        const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
-                        if (reportedContext !== undefined &&
-                            Number.isSafeInteger(reportedContext) &&
-                            reportedContext >= 0) {
-                            input.observeContextTokens(reportedContext);
-                            roundServerUsage = {
-                                contextInputTokens: reportedContext,
-                                outputTokens: typeof event.usage.outputTokens === 'number' &&
-                                    Number.isSafeInteger(event.usage.outputTokens) &&
-                                    event.usage.outputTokens >= 0
-                                    ? event.usage.outputTokens
-                                    : undefined
-                            };
-                        }
-                        await input.publish({ type: 'usage.updated', ...publicModelUsage(event.usage) });
-                    }
-                    else if (event.type === 'reasoning.completed') {
-                        if (mode !== 'compact' && event.text.trim() && !publishedReasoning.has(event.itemId)) {
-                            await input.publish({
-                                type: 'reasoning.completed',
-                                itemId: `${reasoningScope}:${event.itemId}`,
-                                representation: event.representation,
-                                text: event.text
-                            });
-                            publishedReasoning.add(event.itemId);
-                        }
-                    }
-                    else if (event.type === 'hosted_tool') {
-                        if (mode !== 'compact')
-                            for (const toolEvent of publicHostedToolEvents(event))
-                                await input.publish(toolEvent);
-                    }
-                    else if (event.type === 'citation') {
-                        if (mode !== 'compact')
-                            await input.publish({
-                                type: 'citation.added',
-                                id: event.citation.id,
-                                url: event.citation.url,
-                                ...(event.citation.title ? { title: event.citation.title } : {})
-                            });
-                    }
-                    else if (event.type === 'client_tool.call') {
-                        if (mode === 'compact')
-                            throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
-                        sawTool = true;
-                        pendingTools.push(event);
-                    }
-                    else if (event.type === 'completed') {
-                        stop = event.reason;
-                        requestCompletedAt = observedAt;
-                    }
-                    if (isFirstModelResponse)
-                        await emitLatency();
-                }
-                if (mode !== 'compact' &&
-                    stop !== 'cancelled' &&
-                    !input.signal.aborted &&
-                    requestCompletedAt !== undefined)
-                    await emitFinalPerformance(requestCompletedAt);
-                pendingOutputContinuation = undefined;
-                incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
-                if (!(stop === 'max_output' && incompleteToolCall)) {
-                    await persistToolCalls(pendingTools);
-                }
-                else
-                    pendingTools.splice(0, pendingTools.length);
-            }
-            catch (error) {
-                this.planOutputPrefixes.clear();
-                if (await recoverModelStream(error, modelRetryState, input.recoverySignal())) {
-                    this.finalAnswer = '';
-                    if (mode === 'compact')
-                        messages.splice(roundMessageCount);
-                    if (pendingTools.some((call) => call.argumentError !== undefined))
-                        pendingTools.splice(0, pendingTools.length);
-                    else if (pendingTools.length > 0)
-                        await persistToolCalls(pendingTools);
-                    if (pendingTools.length === 0)
-                        continue;
-                }
-                else if (mode === 'compact' &&
-                    !sawModelSemanticEvent &&
-                    isProviderContextOverflow(error) &&
-                    input.compactionFallback?.()) {
-                    modelRetryState.attempts = 0;
-                    this.finalAnswer = '';
-                    continue;
-                }
-                else if (mode !== 'compact' &&
-                    !sawModelSemanticEvent &&
-                    isProviderContextOverflow(error)) {
-                    if (!recoveringFromContextOverflow && (await input.compactContext())) {
-                        modelRetryState.attempts = 0;
-                        recoveringFromContextOverflow = true;
-                        continue;
-                    }
-                    throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The model rejected the compacted context as too large.', { cause: error });
-                }
-                else
-                    throw error;
-            }
-            recoveringFromContextOverflow = false;
-            input.observeUsage(roundServerUsage);
-            const emptyCompletion = stop === 'completed' && !sawTool && !this.finalAnswer.trim();
-            await input.afterModel?.(pendingTools.length ? roundMessageCount : messages.length, emptyCompletion || stop === 'cancelled' ? undefined : round.request);
-            const toolResults = await executeRoundTools(pendingTools, round.toolScope);
-            for (const result of toolResults) {
-                if ('sourceImages' in result && result.sourceImages?.length)
-                    input.toolImages.push(...result.sourceImages
-                        .filter((image) => image.dataBase64 !== undefined)
-                        .map((image) => ({
-                        mimeType: image.mimeType,
-                        data: Buffer.from(image.dataBase64, 'base64')
-                    })));
-                const toolSearchTools = result.call.name === 'tool_search' && !result.failed
-                    ? result.output.toolSearchTools
-                    : undefined;
-                const message = {
-                    role: 'tool',
-                    callId: result.call.callId,
-                    name: result.call.name,
-                    isError: result.failed,
-                    content: result.content,
-                    ...(result.calls ? { calls: result.calls } : {}),
-                    ...(result.observations ? { observations: result.observations } : {}),
-                    ...(toolSearchTools === undefined ? {} : { toolSearchTools }),
-                    ...('images' in result && result.images?.length ? { images: result.images } : {})
-                };
-                messages.push(message);
-                await input.appendContext({
-                    role: message.role,
-                    callId: result.call.callId,
-                    name: result.call.name,
-                    isError: result.failed,
-                    content: message.content,
-                    ...(message.calls ? { calls: message.calls } : {}),
-                    ...(message.observations ? { observations: message.observations } : {}),
-                    ...(message.images?.length
-                        ? { images: message.images.map(({ dataBase64: _bytes, ...image }) => image) }
-                        : {}),
-                    ...(message.toolSearchTools === undefined
-                        ? {}
-                        : { toolSearchTools: message.toolSearchTools })
-                });
-            }
-            if (sawTool) {
-                modelRetryState.attempts = 0;
-                if (input.sourceType === 'subagent')
-                    this.finalAnswer = '';
-            }
-            if (mode !== 'compact' && stop === 'max_output') {
-                const needsContinuation = !sawTool || incompleteToolCall;
-                if (needsContinuation) {
-                    if (maxOutputContinuationUsed)
-                        throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
-                    maxOutputContinuationUsed = true;
-                    pendingOutputContinuation = {
-                        role: 'user',
-                        content: modelOutputContinuationMessage
-                    };
-                    this.finalAnswer = '';
-                    modelRetryState.attempts = 0;
-                    continue;
-                }
-                maxOutputContinuationUsed = false;
-            }
-            else
-                maxOutputContinuationUsed = false;
-            await input.checkpoint(round, latestUsage);
-            if (input.signal.aborted) {
-                const aborted = toolResults.find((result) => result.failed)?.error;
-                throw aborted ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.');
-            }
-            if (input.permissionStop?.()) {
-                input.mailbox.close();
-                this.finalAnswer = '';
-                return { finalAnswer: '', ...(latestUsage === undefined ? {} : { usage: latestUsage }) };
-            }
-            if (input.mailbox.hasPending() && (await input.mailbox.append())) {
-                this.finalAnswer = '';
-                modelRetryState.attempts = 0;
-                continue;
-            }
-            if (stop === 'completed' && !sawTool) {
-                const compactSummary = mode === 'compact' ? this.finalAnswer.trim() : '';
-                if (mode === 'compact' && !compactSummary)
-                    throw new MarAgentError('MAR_AGENT_COMPACT_FAILED', 'Compaction returned an empty handoff.');
-                if (mode !== 'compact' && emptyCompletion) {
-                    const error = new MarAgentError(input.sourceType === 'subagent'
-                        ? 'MAR_AGENT_SUBAGENT_FAILED'
-                        : 'MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', input.sourceType === 'subagent'
-                        ? 'Subagent completed without a final summary.'
-                        : 'Model completed without an answer or tool request.', { retryable: input.sourceType !== 'subagent' });
-                    this.planOutputPrefixes.clear();
-                    if (await recoverModelStream(error, modelRetryState, input.recoverySignal())) {
-                        this.finalAnswer = '';
-                        continue;
-                    }
-                    throw error;
-                }
-                input.mailbox.close();
-                return {
-                    finalAnswer: this.finalAnswer,
-                    ...(latestUsage === undefined ? {} : { usage: latestUsage })
-                };
-            }
-            if (!sawTool && stop !== 'pause')
-                throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model did not complete or request a tool.');
-            modelRetryState.attempts = 0;
-        }
-    }
-}
-function isModelResponseEvent(event) {
-    if (event.type === 'text.delta')
-        return event.delta.length > 0;
-    if (event.type === 'text.completed' || event.type === 'reasoning.completed')
-        return event.text.length > 0;
-    return (event.type === 'response.item' ||
-        event.type === 'output.delta' ||
-        event.type === 'client_tool.call' ||
-        event.type === 'hosted_tool' ||
-        event.type === 'citation');
-}

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

@@ -1,85 +0,0 @@
-import { MarAgentError } from '../error.js';
-const MODEL_PROGRESS_TIMEOUT_MS = 300_000;
-/** Watch normalized generation progress, not transport traffic or consumer processing. */
-export async function* observeModelProgress(start, parent) {
-    parent.throwIfAborted();
-    const controller = new AbortController();
-    const signal = AbortSignal.any([parent, controller.signal]);
-    const iterator = start(signal)[Symbol.asyncIterator]();
-    const hostedStates = new Map();
-    let remainingMs = MODEL_PROGRESS_TIMEOUT_MS;
-    let failed = false;
-    try {
-        for (;;) {
-            signal.throwIfAborted();
-            const startedAt = performance.now();
-            let abort;
-            const timer = setTimeout(() => {
-                controller.abort(new MarAgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model request produced no generation progress for 300 seconds.', { details: { reason: 'MODEL_PROGRESS_TIMEOUT' }, retryable: true }));
-            }, Math.ceil(remainingMs));
-            timer.unref();
-            let next;
-            try {
-                next = await Promise.race([
-                    iterator.next(),
-                    new Promise((_resolve, reject) => {
-                        abort = () => reject(signal.reason);
-                        signal.addEventListener('abort', abort, { once: true });
-                        if (signal.aborted)
-                            abort();
-                    })
-                ]);
-                signal.throwIfAborted();
-            }
-            finally {
-                clearTimeout(timer);
-                if (abort)
-                    signal.removeEventListener('abort', abort);
-            }
-            remainingMs = Math.max(0, remainingMs - (performance.now() - startedAt));
-            if (next.done)
-                return;
-            if (isGenerationProgress(next.value, hostedStates))
-                remainingMs = MODEL_PROGRESS_TIMEOUT_MS;
-            yield next.value;
-        }
-    }
-    catch (error) {
-        failed = true;
-        parent.throwIfAborted();
-        if (signal.aborted)
-            throw signal.reason;
-        throw error;
-    }
-    finally {
-        controller.abort();
-        try {
-            await iterator.return?.();
-        }
-        catch (error) {
-            if (!failed)
-                throw error;
-        }
-    }
-}
-function isGenerationProgress(event, hostedStates) {
-    switch (event.type) {
-        case 'output.delta':
-        case 'client_tool.call':
-        case 'citation':
-        case 'completed':
-            return true;
-        case 'text.delta':
-            return event.delta.length > 0;
-        case 'text.completed':
-        case 'reasoning.completed':
-            return event.text.length > 0;
-        case 'hosted_tool': {
-            const previous = hostedStates.get(event.itemId);
-            hostedStates.set(event.itemId, event.status);
-            return previous !== event.status;
-        }
-        default:
-            return false;
-    }
-}

package/dist/agent-core/runtime/resource-publication.d.ts

@@ -1,8 +0,0 @@
-import type { MarAgentHost } from '../host/contracts.js';
-import type { ModelImage } from '../model/image.js';
-import type { SessionStore } from '../session/store/contracts.js';
-/** Persist immutable bytes first; publication never changes an existing resource URL. */
-export declare function publishModelResources<T extends ModelImage>(host: MarAgentHost, images: readonly T[] | undefined, context: {
-    sessionId: string;
-    executionId: string;
-}, store?: SessionStore): Promise<readonly T[] | undefined>;

package/dist/agent-core/runtime/resource-publication.js

@@ -1,60 +0,0 @@
-import { isModelImageUrl } from '../model/image.js';
-import { MarAgentError } from '../error.js';
-const pending = new WeakMap();
-/** Persist immutable bytes first; publication never changes an existing resource URL. */
-export async function publishModelResources(host, images, context, store) {
-    if (!images?.length)
-        return images;
-    if (store === undefined) {
-        if (host.publishModelResource === undefined)
-            return images;
-        throw new MarAgentError('MAR_AGENT_IMAGE_PUBLICATION_FAILED', 'Image publication requires a SessionStore.');
-    }
-    let publications = pending.get(store);
-    if (publications === undefined)
-        pending.set(store, (publications = new Map()));
-    return Promise.all(images.map(async (image) => {
-        if (image.dataBase64 === undefined &&
-            image.resourceId === undefined &&
-            isModelImageUrl(image.url))
-            return image;
-        let resource = await store.persistResource(context.sessionId, image);
-        if (resource.url === undefined && image.url !== undefined && image.urlExpiresAt !== undefined)
-            resource = await store.setResourceUrl(context.sessionId, resource.resourceId, {
-                url: image.url,
-                urlExpiresAt: image.urlExpiresAt
-            });
-        const key = `${context.sessionId}\0${resource.resourceId}`;
-        let publication = publications.get(key);
-        if (publication === undefined) {
-            publication = (async () => {
-                if (resource.url === undefined && host.publishModelResource !== undefined) {
-                    const published = await host.publishModelResource(resource, {
-                        ...context,
-                        homeDirectory: (await host.describe()).homeDirectory
-                    });
-                    if (published === undefined ||
-                        !isModelImageUrl(published.url) ||
-                        !Number.isSafeInteger(published.urlExpiresAt) ||
-                        published.urlExpiresAt <= 0)
-                        throw new MarAgentError('MAR_AGENT_IMAGE_PUBLICATION_FAILED', 'Image publication did not return a valid fixed URL.');
-                    resource = await store.setResourceUrl(context.sessionId, resource.resourceId, published);
-                }
-                const { sha256: _hash, ...reference } = resource;
-                return resource.url === undefined && image.dataBase64 !== undefined
-                    ? { ...reference, dataBase64: image.dataBase64 }
-                    : reference;
-            })();
-            publications.set(key, publication);
-        }
-        try {
-            const published = await publication;
-            const { dataBase64: _bytes, ...metadata } = image;
-            return { ...metadata, ...published, resourceInputVersion: 1 };
-        }
-        finally {
-            if (publications.get(key) === publication)
-                publications.delete(key);
-        }
-    }));
-}

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

@@ -1,11 +0,0 @@
-import { type MarAgentModelConfiguration } from '../model/configuration.js';
-import type { ModelAdapter } from '../model/contracts.js';
-import type { CreateMarAgentOptions, MarAgent } from './types.js';
-interface InternalCreateMarAgentOptions extends CreateMarAgentOptions {
-    readonly adapterFactory?: (configuration: MarAgentModelConfiguration) => ModelAdapter;
-}
-/** Validate models before Host negotiation and expose only built-in protocol adapters. */
-export declare function createMarAgent(options: CreateMarAgentOptions): Promise<MarAgent>;
-/** Package-internal seam for deterministic adapter tests; not a package export. */
-export declare function createMarAgentWithAdapter(options: InternalCreateMarAgentOptions): Promise<MarAgent>;
-export {};