@myagentroam/agent 0.11.33 → 0.11.35

package/dist/model/recovery.js

@@ -0,0 +1,80 @@
+import { AgentError } from '../error.js';
+import { isAnthropicRecoverableStreamError } from './anthropic-messages.js';
+import { isRetryableModelRequestError, modelRetryMaxAttempts, waitForModelRetry } from './http.js';
+import { isOpenAiResponsesRecoverableStreamError } from './openai-responses.js';
+/** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
+export async function recoverModelStream(error, retryState, signal) {
+    if (signal.aborted ||
+        !((error instanceof AgentError &&
+            error.code === 'MAR_AGENT_MODEL_OUTPUT_INCOMPLETE' &&
+            error.retryable) ||
+            isRetryableModelRequestError(error) ||
+            isOpenAiResponsesRecoverableStreamError(error) ||
+            isAnthropicRecoverableStreamError(error)) ||
+        retryState.attempts >= modelRetryMaxAttempts(retryState))
+        return false;
+    const delayMs = retryState.retryDelayMs;
+    delete retryState.retryDelayMs;
+    try {
+        await waitForModelRetry(typeof error.details?.retryAfter === 'string' ? error.details.retryAfter : null, retryState.attempts - 1, signal, delayMs);
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        throw error;
+    }
+    return true;
+}
+const PROVIDER_CONTEXT_OVERFLOW_CODES = new Set([
+    'mar_agent_context_limit',
+    'context_length_exceeded',
+    'context_overflow',
+    'context_window_exceeded',
+    'prompt_too_long',
+    'request_too_large',
+    'string_above_max_length'
+]);
+const PROVIDER_CONTEXT_OVERFLOW_PATTERNS = [
+    /prompt is too long/iu,
+    /request_too_large/iu,
+    /input is too long for requested model/iu,
+    /exceeds (?:the )?(?:model'?s )?(?:maximum )?context (?:length|window)/iu,
+    /input token count.*exceeds the maximum/iu,
+    /tokens in request more than max tokens allowed/iu,
+    /maximum prompt length is \d+/iu,
+    /reduce the length of the messages/iu,
+    /maximum context length is \d+ tokens/iu,
+    /exceeds (?:the )?maximum allowed input length/iu,
+    /greater than the context length/iu,
+    /context window exceeds limit/iu,
+    /exceeded model token limit/iu,
+    /context[_ ]length[_ ]exceeded/iu,
+    /request entity too large/iu,
+    /input length.*exceeds.*context length/iu,
+    /prompt too long; exceeded (?:max )?context length/iu,
+    /model_context_window_exceeded/iu,
+    /too many tokens/iu,
+    /token limit exceeded/iu
+];
+const PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS = [
+    /^(?:[^:]+: )?(?:throttling error|service unavailable):/iu,
+    /rate limit/iu,
+    /too many requests/iu
+];
+export function isProviderContextOverflow(error) {
+    if (!(error instanceof AgentError))
+        return false;
+    const code = error.code.trim().toLowerCase();
+    if (PROVIDER_CONTEXT_OVERFLOW_CODES.has(code))
+        return true;
+    if (error.details?.status === 413)
+        return true;
+    const message = error.message;
+    // K3-compatible gateways report context overflow as HTTP 401 instead of a
+    // standard provider error code. Keep this exception scoped to that exact shape.
+    if (error.details?.status === 401 && /supports only [\d,.]+[km]? context/iu.test(message))
+        return true;
+    if (code !== 'invalid_request_error' && code !== 'mar_agent_model_protocol_error')
+        return false;
+    return (!PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS.some((pattern) => pattern.test(message)) &&
+        PROVIDER_CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message)));
+}

package/dist/model/request-configuration.d.ts

@@ -0,0 +1,17 @@
+import { type AgentModelConfiguration, type AgentReasoningEffort } from './configuration.js';
+import type { ModelMessage } from './contracts.js';
+/** Resolve request effort and native updates without owning their persistence or timing. */
+export declare function prepareModelConfiguration(model: Pick<AgentModelConfiguration, 'id' | 'protocol' | 'responsesConfigurationUpdates'>, effort: AgentReasoningEffort, context: {
+    readonly baselineEffort: AgentReasoningEffort | undefined;
+    readonly messages: readonly ModelMessage[];
+    readonly checkpointAdopted?: false;
+} | {
+    readonly checkpointAdopted: true;
+}): {
+    readonly requestReasoningEffort?: AgentReasoningEffort;
+    readonly updates: readonly ModelMessage[];
+    readonly contextProjection: {
+        readonly modelProtocol: AgentModelConfiguration['protocol'];
+        readonly responsesConfigurationUpdates: boolean;
+    };
+};

package/dist/model/request-configuration.js

@@ -0,0 +1,47 @@
+import { agentReasoningEffortSchema, usesResponsesConfigurationUpdates } from './configuration.js';
+/** Resolve request effort and native updates without owning their persistence or timing. */
+export function prepareModelConfiguration(model, effort, context) {
+    const useUpdates = usesResponsesConfigurationUpdates(model);
+    const contextProjection = {
+        modelProtocol: model.protocol,
+        responsesConfigurationUpdates: useUpdates
+    };
+    if (context.checkpointAdopted)
+        return { requestReasoningEffort: effort, updates: [], contextProjection };
+    if (!useUpdates)
+        return { updates: [], contextProjection };
+    const requestReasoningEffort = context.baselineEffort ?? effort;
+    const effectiveEffort = context.baselineEffort === undefined
+        ? requestReasoningEffort
+        : (lastConfigurationEffort(context.messages, model.id) ?? requestReasoningEffort);
+    return {
+        requestReasoningEffort,
+        contextProjection,
+        updates: effectiveEffort === effort
+            ? []
+            : [
+                {
+                    role: 'provider',
+                    content: '',
+                    provider: 'OPENAI_RESPONSES',
+                    providerModelId: model.id,
+                    item: { type: 'configuration_update', reasoning: { effort } }
+                }
+            ]
+    };
+}
+function lastConfigurationEffort(messages, modelId) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== 'provider' ||
+            message.provider !== 'OPENAI_RESPONSES' ||
+            message.providerModelId !== modelId ||
+            message.item?.type !== 'configuration_update')
+            continue;
+        const reasoning = message.item.reasoning;
+        const effort = agentReasoningEffortSchema.safeParse(reasoning?.effort);
+        if (effort.success)
+            return effort.data;
+    }
+    return undefined;
+}

package/dist/model/responses-event-projection.d.ts

@@ -0,0 +1,24 @@
+import type { ModelEvent } from './contracts.js';
+/** Per-attempt text assembly; provider events may report final phase after text.done. */
+export declare class ResponsesTextProjection {
+    #private;
+    finish(): Iterable<ModelEvent>;
+    project(event: Record<string, unknown>, type: string): {
+        readonly handled: boolean;
+        readonly event?: ModelEvent;
+    };
+}
+export declare function hostedWebActionInput(action: Record<string, unknown>): {
+    input: Record<string, unknown>;
+    truncated: boolean;
+};
+export declare function hostedWebActionSummary(action: Record<string, unknown>): Extract<ModelEvent, {
+    type: 'hosted_tool';
+}>['summary'];
+export declare function responseItem(value: unknown): Record<string, unknown> | undefined;
+export declare function responseCitations(response: Record<string, unknown>): {
+    id: string;
+    url: string;
+    title?: string;
+}[];
+export declare function responseEventId(event: Record<string, unknown>): string | undefined;

package/dist/model/responses-event-projection.js

@@ -0,0 +1,194 @@
+import { AgentError } from '../error.js';
+import { record, text } from './sse.js';
+/** Per-attempt text assembly; provider events may report final phase after text.done. */
+export class ResponsesTextProjection {
+    #phases = new Map();
+    #pending = new Map();
+    #emitted = new Set();
+    *finish() {
+        for (const [itemId, completedText] of this.#pending) {
+            if (this.#emitted.has(itemId))
+                continue;
+            this.#emitted.add(itemId);
+            yield {
+                type: 'text.completed',
+                itemId,
+                phase: this.#phases.get(itemId) ?? 'final_answer',
+                text: completedText
+            };
+        }
+        this.#pending.clear();
+    }
+    project(event, type) {
+        if ((type === 'response.output_item.added' || type === 'response.output_item.done') &&
+            text(record(event.item).type) === 'message') {
+            const item = record(event.item);
+            const itemId = text(item.id);
+            if (type === 'response.output_item.added') {
+                const phase = messagePhase(item.phase);
+                if (itemId && phase)
+                    this.#phases.set(itemId, phase);
+                return { handled: true };
+            }
+            const id = itemId ?? text(event.item_id) ?? 'text';
+            const phase = messagePhase(item.phase) ?? this.#phases.get(id) ?? 'final_answer';
+            this.#phases.set(id, phase);
+            const completedText = this.#pending.get(id) ?? responseMessageText(item);
+            if (completedText === undefined || this.#emitted.has(id))
+                return { handled: true };
+            this.#emitted.add(id);
+            this.#pending.delete(id);
+            return {
+                handled: true,
+                event: { type: 'text.completed', itemId: id, phase, text: completedText }
+            };
+        }
+        if (type === 'response.output_text.delta')
+            return {
+                handled: true,
+                event: {
+                    type: 'text.delta',
+                    itemId: text(event.item_id) ?? 'text',
+                    phase: messagePhase(event.phase) ??
+                        this.#phases.get(text(event.item_id) ?? '') ??
+                        'commentary',
+                    delta: text(event.delta) ?? ''
+                }
+            };
+        if (type === 'response.output_text.done') {
+            const itemId = text(event.item_id) ?? 'text';
+            const completedText = text(event.text) ?? '';
+            const phase = messagePhase(event.phase) ?? this.#phases.get(itemId);
+            if (this.#emitted.has(itemId))
+                return { handled: true };
+            if (!phase) {
+                this.#pending.set(itemId, completedText);
+                return { handled: true };
+            }
+            this.#emitted.add(itemId);
+            return {
+                handled: true,
+                event: { type: 'text.completed', itemId, phase, text: completedText }
+            };
+        }
+        return { handled: false };
+    }
+}
+function messagePhase(value) {
+    return value === 'commentary' || value === 'final_answer' ? value : undefined;
+}
+function responseMessageText(item) {
+    const content = Array.isArray(item.content) ? item.content : [];
+    const parts = content
+        .map(record)
+        .filter((part) => text(part.type) === 'output_text')
+        .map((part) => text(part.text) ?? '');
+    return parts.length ? parts.join('') : undefined;
+}
+const RESPONSE_ITEM_TYPES = new Set([
+    'message',
+    'reasoning',
+    'function_call',
+    'custom_tool_call',
+    'tool_search_call',
+    'tool_search_output',
+    'web_search_call'
+]);
+// A freeform patch item can contain the complete 4 MiB patch plus its JSON envelope.
+const MAX_RESPONSE_ITEM_BYTES = 5 * 1024 * 1024;
+export function hostedWebActionInput(action) {
+    const input = {};
+    let truncated = false;
+    for (const [key, limit] of [
+        ['type', 128],
+        ['query', 10_000],
+        ['url', 2_048],
+        ['pattern', 10_000]
+    ]) {
+        const value = action[key];
+        if (typeof value !== 'string')
+            continue;
+        input[key] = value.slice(0, limit);
+        truncated ||= value.length > limit;
+    }
+    if (Array.isArray(action.queries)) {
+        const queries = action.queries.filter((value) => typeof value === 'string');
+        input.queries = queries.slice(0, 10).map((value) => value.slice(0, 10_000));
+        truncated ||=
+            queries.length > 10 || queries.slice(0, 10).some((value) => value.length > 10_000);
+    }
+    return { input, truncated };
+}
+export function hostedWebActionSummary(action) {
+    const queries = Array.isArray(action.queries)
+        ? action.queries
+            .slice(0, 10)
+            .filter((query) => typeof query === 'string' && query.length > 0)
+        : [];
+    const query = text(action.query) || queries.join('\n');
+    const url = text(action.url);
+    const title = text(action.title);
+    const sources = Array.isArray(action.sources)
+        ? action.sources
+            .slice(0, 20)
+            .map((source) => {
+            const value = record(source);
+            const sourceUrl = text(value.url);
+            if (!sourceUrl)
+                return undefined;
+            const sourceTitle = text(value.title);
+            const snippet = text(value.snippet);
+            return {
+                url: sourceUrl.slice(0, 2048),
+                ...(sourceTitle ? { title: sourceTitle.slice(0, 256) } : {}),
+                ...(snippet ? { snippet: snippet.slice(0, 2000) } : {})
+            };
+        })
+            .filter((source) => source !== undefined)
+        : [];
+    return {
+        ...(query ? { query: query.slice(0, 10_000) } : {}),
+        ...(url ? { url: url.slice(0, 2048) } : {}),
+        ...(title ? { title: title.slice(0, 256) } : {}),
+        ...(Array.isArray(action.sources) ? { sources } : {}),
+        ...(Array.isArray(action.sources) && action.sources.length > 20
+            ? { sourcesTruncated: true }
+            : {})
+    };
+}
+export function responseItem(value) {
+    const item = record(value);
+    const itemType = text(item.type);
+    if (!itemType || !RESPONSE_ITEM_TYPES.has(itemType))
+        return undefined;
+    const serialized = JSON.stringify(item);
+    if (Buffer.byteLength(serialized) > MAX_RESPONSE_ITEM_BYTES)
+        throw new AgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Responses output item exceeds the context record limit.');
+    return JSON.parse(serialized);
+}
+export function responseCitations(response) {
+    const citations = new Map();
+    for (const output of Array.isArray(response.output) ? response.output : []) {
+        const item = record(output);
+        for (const content of Array.isArray(item.content) ? item.content : []) {
+            const part = record(content);
+            for (const value of Array.isArray(part.annotations) ? part.annotations : []) {
+                const annotation = record(value);
+                const url = text(annotation.url);
+                if (!url)
+                    continue;
+                const id = text(annotation.id) ?? `${text(item.id) ?? 'text'}-${citations.size}`;
+                const title = text(annotation.title);
+                citations.set(`${id}:${url}`, {
+                    id,
+                    url,
+                    ...(title ? { title } : {})
+                });
+            }
+        }
+    }
+    return [...citations.values()];
+}
+export function responseEventId(event) {
+    return text(record(event.response).id);
+}

package/dist/model/responses-request.d.ts

@@ -0,0 +1,5 @@
+import { type AgentModelConfiguration } from './configuration.js';
+import type { ModelRequest } from './contracts.js';
+import type { ResponsesRequestBody } from './responses-session-cache.js';
+export declare function responsesRequestBody(configuration: AgentModelConfiguration, request: ModelRequest, messages: ModelRequest['messages'], previousOutputItems?: readonly Record<string, unknown>[]): ResponsesRequestBody;
+export declare function openAiInput(messages: ModelRequest['messages'], images: ModelRequest['images'] | undefined, modelId: string, requireEncryptedReasoning: boolean, configurationUpdates?: boolean, nativeTools?: boolean, tools?: ModelRequest['tools'], previousOutputItems?: readonly Record<string, unknown>[]): Record<string, unknown>[];