@myagentroam/agent 0.11.33 → 0.11.35

package/dist/model/http.js

@@ -0,0 +1,119 @@
+import { isRetryableTransportError, TransportFault } from '../network/transport-error.js';
+export { isRetryableTransportError as isRetryableModelTransportError } from '../network/transport-error.js';
+import { setTimeout as delay } from 'node:timers/promises';
+import { AgentError } from '../error.js';
+import { connectSocks5Target as connectTransportSocks5Target, fetchWithConnectionTimeout, hasErrorCode, isModelHttpAttempt } from '../network/http.js';
+export const MAX_MODEL_ATTEMPTS = 8;
+export function modelRetryMaxAttempts(state) {
+    const maximum = state.maxAttempts ?? MAX_MODEL_ATTEMPTS;
+    if (!Number.isInteger(maximum) || maximum < 1 || maximum > MAX_MODEL_ATTEMPTS)
+        throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', `Model attempts must be between 1 and ${MAX_MODEL_ATTEMPTS}.`);
+    return maximum;
+}
+const RETRYABLE_STATUS = new Set([408, 409, 429, 500, 502, 503, 504]);
+const DEFAULT_MODEL_CONNECTION_TIMEOUT_MS = 30_000;
+export async function connectSocks5Target(input) {
+    try {
+        return await connectTransportSocks5Target(input);
+    }
+    catch (error) {
+        if (input.signal?.aborted)
+            throw input.signal.reason;
+        if (error instanceof TransportFault && error.kind === 'invalid-proxy')
+            throw projectTransportFault(error);
+        throw error;
+    }
+}
+function projectTransportFault(error) {
+    if (error.kind === 'connection-timeout')
+        return new AgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model connection timed out.', {
+            details: { reason: 'MODEL_CONNECTION_TIMEOUT' },
+            retryable: true
+        });
+    if (error.kind === 'http2-negotiation')
+        return new AgentError('MAR_AGENT_MODEL_CONNECTION_FAILED', 'Model endpoint did not negotiate HTTP/2.', { cause: error.cause });
+    return new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'SOCKS5 proxy URL is invalid.', error.cause === undefined ? undefined : { cause: error.cause });
+}
+function modelTransportFailure(error, attempts) {
+    return new AgentError(hasErrorCode(error, 'ETIMEDOUT') ||
+        hasErrorCode(error, 'UND_ERR_CONNECT_TIMEOUT') ||
+        hasErrorCode(error, 'UND_ERR_HEADERS_TIMEOUT')
+        ? 'MAR_AGENT_MODEL_TIMEOUT'
+        : 'MAR_AGENT_MODEL_CONNECTION_FAILED', attempts === 1
+        ? 'Model transport request failed.'
+        : 'Model transport request failed after retries.', { retryable: true, details: { reason: 'MODEL_TRANSPORT_FAILURE' }, cause: error });
+}
+export async function fetchModelResponse(url, init, signal, attempts = MAX_MODEL_ATTEMPTS, connectionTimeoutMs = DEFAULT_MODEL_CONNECTION_TIMEOUT_MS) {
+    let response;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const resolved = typeof init === 'function' ? await init() : init;
+            const attempt = isModelHttpAttempt(resolved)
+                ? resolved
+                : { request: resolved, httpVersion: '1.1' };
+            response = await fetchWithConnectionTimeout(url, attempt, signal, connectionTimeoutMs);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason ?? error;
+            if (error instanceof Error &&
+                error.cause instanceof TransportFault &&
+                error.cause.kind === 'invalid-proxy') {
+                error.cause = projectTransportFault(error.cause);
+                throw error;
+            }
+            if (error instanceof TransportFault && error.kind !== 'connection-timeout')
+                throw projectTransportFault(error);
+            if ((error instanceof TransportFault && error.kind === 'connection-timeout') ||
+                (error instanceof AgentError &&
+                    error.code === 'MAR_AGENT_MODEL_TIMEOUT' &&
+                    error.details?.reason === 'MODEL_CONNECTION_TIMEOUT')) {
+                if (attempt + 1 >= attempts)
+                    throw error instanceof TransportFault ? projectTransportFault(error) : error;
+                await waitForModelRetry(null, attempt, signal);
+                continue;
+            }
+            if (!isRetryableTransportError(error))
+                throw error;
+            if (attempt + 1 >= attempts)
+                throw modelTransportFailure(error, attempts);
+            await waitForModelRetry(null, attempt, signal);
+            continue;
+        }
+        if (!RETRYABLE_STATUS.has(response.status) || attempt + 1 >= attempts)
+            return response;
+        const retryAfter = response.headers.get('retry-after');
+        await response.body?.cancel().catch(() => undefined);
+        await waitForModelRetry(retryAfter, attempt, signal);
+    }
+    return response;
+}
+export function modelRetryDelay(retryAfter, attempt) {
+    return retryAfterDelay(retryAfter) ?? (attempt + 1) * 5_000 + Math.floor(Math.random() * 3_001);
+}
+export async function waitForModelRetry(retryAfter, attempt, signal, delayMs = modelRetryDelay(retryAfter, attempt)) {
+    await delay(delayMs, undefined, { signal });
+}
+export function isRetryableModelHttpStatus(status) {
+    return RETRYABLE_STATUS.has(status);
+}
+export function isRetryableModelRequestError(error) {
+    return (error instanceof AgentError &&
+        error.retryable &&
+        (error.details?.reason === 'MODEL_PROGRESS_TIMEOUT' ||
+            error.details?.reason === 'MODEL_CONNECTION_TIMEOUT' ||
+            error.details?.reason === 'MODEL_TRANSPORT_FAILURE' ||
+            (typeof error.details?.status === 'number' &&
+                isRetryableModelHttpStatus(error.details.status))));
+}
+function retryAfterDelay(value) {
+    if (value !== null) {
+        const seconds = Number(value);
+        if (Number.isFinite(seconds))
+            return Math.min(30_000, Math.max(0, seconds * 1000));
+        const date = Date.parse(value);
+        if (Number.isFinite(date))
+            return Math.min(30_000, Math.max(0, date - Date.now()));
+    }
+    return undefined;
+}

package/dist/model/image-contract.d.ts

@@ -0,0 +1,10 @@
+export interface ModelImage {
+    readonly resourceInputVersion?: 1;
+    readonly mimeType: string;
+    readonly dataBase64?: string;
+    readonly resourceId?: string;
+    readonly byteSize?: number;
+    /** Fixed published resource; image bytes are persisted separately. */
+    readonly url?: string;
+    readonly urlExpiresAt?: number;
+}

package/dist/model/image.d.ts

@@ -0,0 +1,9 @@
+import type { ModelImage } from './image-contract.js';
+export type { ModelImage } from './image-contract.js';
+export declare function modelImageUrl(image: ModelImage): string;
+export declare function modelImageKey(image: ModelImage): string;
+/** Only immutable URL references may enter durable model history. */
+export declare function persistedModelImages(images: readonly ModelImage[] | undefined): ModelImage[];
+/** Durable images contain a URL or resource reference, never inline image bytes. */
+export declare function parseModelImages(value: unknown): ModelImage[] | undefined;
+export declare function isModelImageUrl(value: unknown): value is string;

package/dist/model/inline-media-budget.d.ts

@@ -0,0 +1,7 @@
+import { type ModelImage } from './image.js';
+import type { ModelRequest } from './contracts.js';
+export declare const REQUEST_INLINE_MEDIA_HARD_LIMIT: number;
+export declare function inlineMediaBytes(image: ModelImage): number;
+export declare function inlineMediaLimit(): never;
+/** Final encoding guard; URL-only images do not consume the inline budget. */
+export declare function assertInlineMediaBudget(request: Pick<ModelRequest, 'messages' | 'images'>): void;

package/dist/model/inline-media-budget.js

@@ -0,0 +1,36 @@
+import { AgentError } from '../error.js';
+import { isModelImageUrl } from './image.js';
+import { isRealUserMessage, uniqueModelImages } from './input-images.js';
+export const REQUEST_INLINE_MEDIA_HARD_LIMIT = 12 * 1_048_576;
+export function inlineMediaBytes(image) {
+    const bytes = image.dataBase64 !== undefined
+        ? image.dataBase64.length
+        : image.byteSize !== undefined
+            ? 4 * Math.ceil(image.byteSize / 3)
+            : undefined;
+    if (bytes === undefined)
+        throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Resource size is unavailable.');
+    return bytes + Buffer.byteLength(`data:${image.mimeType};base64,`);
+}
+export function inlineMediaLimit() {
+    throw new AgentError('MAR_AGENT_INLINE_MEDIA_LIMIT', 'Inline images exceed the 12 MiB request limit. Reduce this image batch or use view_image with resize or region before retrying.');
+}
+/** Final encoding guard; URL-only images do not consume the inline budget. */
+export function assertInlineMediaBudget(request) {
+    let total = 0;
+    const lastUser = request.messages.findLastIndex(isRealUserMessage);
+    for (const [index, message] of request.messages.entries()) {
+        const images = message.role === 'tool'
+            ? message.textBlocks === undefined && message.contentParts !== undefined
+                ? message.contentParts.flatMap((part) => (part.type === 'image' ? [part.image] : []))
+                : (message.images ?? [])
+            : message.role === 'user'
+                ? uniqueModelImages(message.images, index === lastUser ? request.images : undefined)
+                : [];
+        for (const image of images)
+            if (!isModelImageUrl(image.url) && image.dataBase64 !== undefined)
+                total += inlineMediaBytes(image);
+    }
+    if (total > REQUEST_INLINE_MEDIA_HARD_LIMIT)
+        inlineMediaLimit();
+}

package/dist/model/input-images.d.ts

@@ -0,0 +1,3 @@
+import type { ModelRequest } from './contracts.js';
+export declare function isRealUserMessage(message: ModelRequest['messages'][number]): boolean;
+export declare function uniqueModelImages(...groups: Array<ModelRequest['images'] | undefined>): Array<NonNullable<ModelRequest['images']>[number]>;

package/dist/model/input-images.js

@@ -0,0 +1,16 @@
+import { modelImageKey } from './image.js';
+export function isRealUserMessage(message) {
+    return (message.role === 'user' &&
+        message.contextKind === undefined &&
+        message.contextualBlock === undefined);
+}
+export function uniqueModelImages(...groups) {
+    const seen = new Set();
+    return groups.flatMap((group) => (group ?? []).flatMap((image) => {
+        const key = modelImageKey(image);
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        return [image];
+    }));
+}

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

@@ -0,0 +1,59 @@
+export { openAiInput } from './responses-request.js';
+import { AgentError } from '../error.js';
+import { type AgentModelConfiguration, type ModelCredentialAcquireReason } from './configuration.js';
+import WebSocket from 'ws';
+import type { ModelAdapter, ModelAttemptDiagnostic, ModelEvent, ModelRequest, ModelTurnSession } from './contracts.js';
+import { ResponsesSessionCache, type ResponsesRequestBody, type ResponsesSessionState } from './responses-session-cache.js';
+export declare const OPENAI_RESPONSES_EARLY_EOF_REASON = "OPENAI_RESPONSES_EARLY_EOF";
+export declare const OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON = "OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT";
+interface PreparedResponsesRequest {
+    readonly inputItemCount: number;
+    readonly fullBody: ResponsesRequestBody;
+    readonly body: ResponsesRequestBody;
+    readonly continuation: boolean;
+}
+type ResponsesWebSocketDiagnostic = Pick<ModelAttemptDiagnostic, 'requestBytes' | 'imageCount' | 'imageBytes' | 'requestFrameCount' | 'sentFrameCount' | 'webSocketPhase' | 'webSocketCloseCode'>;
+export declare class OpenAiResponsesAdapter implements ModelAdapter {
+    #private;
+    constructor(configuration: AgentModelConfiguration);
+    get configuration(): AgentModelConfiguration;
+    prepareReconfigure(configuration: AgentModelConfiguration): (() => void) | undefined;
+    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
+    createTurnSession(): ModelTurnSession;
+    close(): Promise<void>;
+    startTurn(request: ModelRequest, signal: AbortSignal, turn: OpenAiResponsesTurnSession, prepared: PreparedResponsesRequest): AsyncIterable<ModelEvent>;
+    private startAttempt;
+}
+declare class OpenAiResponsesTurnSession implements ModelTurnSession {
+    #private;
+    private readonly adapter;
+    private readonly cache;
+    private readonly state;
+    private readonly cacheLease;
+    constructor(adapter: OpenAiResponsesAdapter, cache: ResponsesSessionCache, state: ResponsesSessionState, cacheLease: boolean);
+    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
+    private run;
+    close(): Promise<void>;
+    resetContinuation(): void;
+    continuationInputCount(): number;
+    commitContinuationInput(messageCount: number): void;
+    captureCompletedResponseId(responseId: string | undefined): void;
+    prepareRequest(request: ModelRequest): PreparedResponsesRequest;
+    currentTurnState(): string | undefined;
+    beginAttempt(): void;
+    captureWebSocketDiagnostic(diagnostic: ResponsesWebSocketDiagnostic): void;
+    connectionDiagnostic(): Pick<ModelAttemptDiagnostic, 'connectionId' | 'connectionReused' | 'proxyType'> & ResponsesWebSocketDiagnostic;
+    captureTurnState(value: unknown): void;
+    withTurnStateMetadata(body: ResponsesRequestBody): ResponsesRequestBody;
+    invalidateWebSocket(): void;
+    webSocketForRequest(input: {
+        readonly configuration: AgentModelConfiguration;
+        readonly promptCacheKey: string | undefined;
+        readonly reason: ModelCredentialAcquireReason;
+        readonly signal: AbortSignal;
+        readonly continuation: boolean;
+        readonly credentialAcquired: (revision: number) => void;
+    }): Promise<WebSocket>;
+    private connectWebSocket;
+}
+export declare function isOpenAiResponsesRecoverableStreamError(error: unknown): error is AgentError;