@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/model/http.js

@@ -1,534 +0,0 @@
-import { setTimeout as delay } from 'node:timers/promises';
-import { connect as connectTcp } from 'node:net';
-import { connect as connectTls } from 'node:tls';
-import { Client, Socks5ProxyAgent, buildConnector, fetch as undiciFetch } from 'undici';
-import { MarAgentError } from '../error.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 MarAgentError('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;
-const SOCKS5_HANDSHAKE_TIMEOUT_MS = 10_000;
-const RETRYABLE_TRANSPORT_CODES = new Set([
-    'EAI_AGAIN',
-    'ENOTFOUND',
-    'ECONNREFUSED',
-    'ECONNRESET',
-    'EHOSTUNREACH',
-    'ENETDOWN',
-    'ENETUNREACH',
-    'EPIPE',
-    'ETIMEDOUT',
-    'UND_ERR_CONNECT_TIMEOUT',
-    'UND_ERR_HEADERS_TIMEOUT',
-    'UND_ERR_SOCKET'
-]);
-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 (isModelConnectionTimeout(error)) {
-                if (attempt + 1 >= attempts)
-                    throw error;
-                await waitForModelRetry(null, attempt, signal);
-                continue;
-            }
-            if (!isRetryableModelTransportError(error))
-                throw error;
-            if (attempt + 1 >= attempts)
-                throw new MarAgentError(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 });
-            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;
-}
-async function fetchWithConnectionTimeout(url, attempt, signal, connectionTimeoutMs) {
-    if (signal.aborted)
-        throw signal.reason;
-    const controller = new AbortController();
-    const timeoutError = new MarAgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model connection timed out.', {
-        details: { reason: 'MODEL_CONNECTION_TIMEOUT' },
-        retryable: true
-    });
-    let rejectInterruption = () => undefined;
-    const interruption = new Promise((_resolve, reject) => {
-        rejectInterruption = reject;
-    });
-    const abortFromCaller = () => {
-        const reason = signal.reason;
-        controller.abort(reason);
-        rejectInterruption(reason);
-    };
-    signal.addEventListener('abort', abortFromCaller, { once: true });
-    const timeout = setTimeout(() => {
-        controller.abort(timeoutError);
-        rejectInterruption(timeoutError);
-    }, Math.max(1, connectionTimeoutMs));
-    try {
-        return await Promise.race([fetchHttpAttempt(url, attempt, controller.signal), interruption]);
-    }
-    finally {
-        clearTimeout(timeout);
-        signal.removeEventListener('abort', abortFromCaller);
-    }
-}
-async function fetchHttpAttempt(url, attempt, signal) {
-    if (attempt.httpVersion === '1.1' && attempt.socks5Url === undefined)
-        return await fetch(url, { ...attempt.request, signal });
-    const dispatcher = attempt.socks5Url === undefined
-        ? http2Client(url)
-        : attempt.httpVersion === '2'
-            ? http2SocksClient(url, attempt.socks5Url)
-            : new Socks5ProxyAgent(attempt.socks5Url);
-    try {
-        const response = await undiciFetch(url, {
-            ...attempt.request,
-            signal,
-            dispatcher
-        });
-        return responseWithDispatcherLifecycle(response, dispatcher);
-    }
-    catch (error) {
-        await dispatcher.destroy(error instanceof Error ? error : null).catch(() => undefined);
-        if (hasErrorCode(error, 'MAR_AGENT_HTTP2_NEGOTIATION_FAILED'))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONNECTION_FAILED', 'Model endpoint did not negotiate HTTP/2.', { cause: error });
-        throw error;
-    }
-}
-function http2Client(url) {
-    return new Client(new URL(url).origin, {
-        allowH2: true,
-        connect: strictHttp2Connector()
-    });
-}
-function http2SocksClient(url, socks5Url) {
-    return new Client(new URL(url).origin, {
-        allowH2: true,
-        connect: async (options, callback) => {
-            try {
-                const tlsSocket = await connectSocks5Target({
-                    socks5Url,
-                    targetHost: options.hostname,
-                    targetPort: Number(options.port || 443),
-                    tls: true,
-                    servername: options.servername || options.hostname,
-                    alpnProtocols: ['h2'],
-                    requiredAlpnProtocol: 'h2'
-                });
-                callback(null, tlsSocket);
-            }
-            catch (error) {
-                callback(asError(error), null);
-            }
-        }
-    });
-}
-export async function connectSocks5Target(input) {
-    if (input.signal?.aborted)
-        throw input.signal.reason;
-    const proxy = parseSocks5Proxy(input.socks5Url);
-    const targetHost = Buffer.from(input.targetHost, 'utf8');
-    if (targetHost.length === 0 ||
-        targetHost.length > 255 ||
-        !Number.isSafeInteger(input.targetPort) ||
-        input.targetPort < 1 ||
-        input.targetPort > 65_535)
-        throw invalidSocks5Proxy();
-    const socket = connectTcp({ host: proxy.hostname, port: proxy.port });
-    const timeoutError = Object.assign(new Error('SOCKS5 connection timed out.'), {
-        code: 'ETIMEDOUT'
-    });
-    const abort = () => socket.destroy(asError(input.signal?.reason));
-    const timeout = () => socket.destroy(timeoutError);
-    input.signal?.addEventListener('abort', abort, { once: true });
-    socket.setTimeout(SOCKS5_HANDSHAKE_TIMEOUT_MS);
-    socket.once('timeout', timeout);
-    try {
-        await waitForSocketConnect(socket);
-        const methods = proxy.username === undefined ? [0x00] : [0x00, 0x02];
-        await writeSocket(socket, Buffer.from([0x05, methods.length, ...methods]));
-        const greeting = await readSocketExactly(socket, 2);
-        if (greeting[0] !== 0x05 || greeting[1] === 0xff)
-            throw socks5ProtocolError('EACCES', 'SOCKS5 proxy rejected authentication methods.');
-        if (greeting[1] === 0x02) {
-            if (proxy.username === undefined || proxy.password === undefined)
-                throw socks5ProtocolError('EACCES', 'SOCKS5 proxy requires authentication.');
-            const username = Buffer.from(proxy.username, 'utf8');
-            const password = Buffer.from(proxy.password, 'utf8');
-            await writeSocket(socket, Buffer.concat([
-                Buffer.from([0x01, username.length]),
-                username,
-                Buffer.from([password.length]),
-                password
-            ]));
-            const authentication = await readSocketExactly(socket, 2);
-            if (authentication[0] !== 0x01 || authentication[1] !== 0x00)
-                throw socks5ProtocolError('EACCES', 'SOCKS5 proxy authentication failed.');
-        }
-        else if (greeting[1] !== 0x00)
-            throw socks5ProtocolError('EACCES', 'SOCKS5 proxy selected an unsupported method.');
-        const port = Buffer.allocUnsafe(2);
-        port.writeUInt16BE(input.targetPort);
-        await writeSocket(socket, Buffer.concat([Buffer.from([0x05, 0x01, 0x00, 0x03, targetHost.length]), targetHost, port]));
-        const reply = await readSocketExactly(socket, 4);
-        if (reply[0] !== 0x05 || reply[2] !== 0x00)
-            throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid response.');
-        if (reply[1] !== 0x00)
-            throw socks5ReplyError(reply[1]);
-        await consumeSocks5BoundAddress(socket, reply[3]);
-        socket.setTimeout(0);
-        socket.off('timeout', timeout);
-        input.signal?.removeEventListener('abort', abort);
-        if (!input.tls)
-            return socket;
-        return await upgradeSocks5Tls(socket, input);
-    }
-    catch (error) {
-        socket.destroy();
-        throw error;
-    }
-    finally {
-        socket.off('timeout', timeout);
-        input.signal?.removeEventListener('abort', abort);
-    }
-}
-function parseSocks5Proxy(value) {
-    try {
-        const url = new URL(value);
-        const port = url.port === '' ? 1080 : Number(url.port);
-        if (url.protocol !== 'socks5:' ||
-            url.hostname.length === 0 ||
-            !Number.isSafeInteger(port) ||
-            port < 1 ||
-            port > 65_535 ||
-            (url.pathname !== '' && url.pathname !== '/') ||
-            url.search !== '' ||
-            url.hash !== '')
-            throw invalidSocks5Proxy();
-        const hasAuthentication = url.username !== '' || url.password !== '';
-        const username = hasAuthentication ? decodeURIComponent(url.username) : undefined;
-        const password = hasAuthentication ? decodeURIComponent(url.password) : undefined;
-        if ((hasAuthentication && username?.length === 0) ||
-            (username !== undefined && Buffer.byteLength(username) > 255) ||
-            (password !== undefined && Buffer.byteLength(password) > 255))
-            throw invalidSocks5Proxy();
-        return {
-            hostname: url.hostname,
-            port,
-            ...(username === undefined ? {} : { username, password: password ?? '' })
-        };
-    }
-    catch (cause) {
-        if (cause instanceof MarAgentError)
-            throw cause;
-        throw invalidSocks5Proxy(cause);
-    }
-}
-async function waitForSocketConnect(socket) {
-    if (socket.readyState === 'open')
-        return;
-    await new Promise((resolve, reject) => {
-        const cleanup = () => {
-            socket.off('connect', connected);
-            socket.off('error', failed);
-            socket.off('close', closed);
-        };
-        const connected = () => {
-            cleanup();
-            resolve();
-        };
-        const failed = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const closed = () => {
-            cleanup();
-            reject(Object.assign(new Error('SOCKS5 proxy connection closed.'), { code: 'ECONNRESET' }));
-        };
-        socket.once('connect', connected);
-        socket.once('error', failed);
-        socket.once('close', closed);
-    });
-}
-async function writeSocket(socket, value) {
-    await new Promise((resolve, reject) => {
-        socket.write(value, (error) => (error ? reject(error) : resolve()));
-    });
-}
-async function readSocketExactly(socket, length) {
-    while (socket.readableLength < length) {
-        if (socket.readableEnded || socket.destroyed)
-            throw Object.assign(new Error('SOCKS5 proxy connection ended early.'), {
-                code: 'ECONNRESET'
-            });
-        await new Promise((resolve, reject) => {
-            const cleanup = () => {
-                socket.off('readable', readable);
-                socket.off('error', failed);
-                socket.off('end', ended);
-                socket.off('close', ended);
-            };
-            const readable = () => {
-                cleanup();
-                resolve();
-            };
-            const failed = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const ended = () => {
-                cleanup();
-                reject(Object.assign(new Error('SOCKS5 proxy connection ended early.'), {
-                    code: 'ECONNRESET'
-                }));
-            };
-            socket.once('readable', readable);
-            socket.once('error', failed);
-            socket.once('end', ended);
-            socket.once('close', ended);
-        });
-    }
-    const value = socket.read(length);
-    if (!Buffer.isBuffer(value) || value.length !== length)
-        throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid response.');
-    return value;
-}
-async function consumeSocks5BoundAddress(socket, addressType) {
-    if (addressType === 0x01) {
-        await readSocketExactly(socket, 6);
-        return;
-    }
-    if (addressType === 0x04) {
-        await readSocketExactly(socket, 18);
-        return;
-    }
-    if (addressType === 0x03) {
-        const length = (await readSocketExactly(socket, 1))[0];
-        await readSocketExactly(socket, length + 2);
-        return;
-    }
-    throw socks5ProtocolError('EPROTO', 'SOCKS5 proxy returned an invalid address.');
-}
-async function upgradeSocks5Tls(socket, input) {
-    const tlsSocket = connectTls({
-        socket,
-        servername: input.servername ?? input.targetHost,
-        ...(input.alpnProtocols === undefined ? {} : { ALPNProtocols: [...input.alpnProtocols] })
-    });
-    const abort = () => tlsSocket.destroy(asError(input.signal?.reason));
-    const timeoutError = Object.assign(new Error('TLS connection timed out.'), {
-        code: 'ETIMEDOUT'
-    });
-    const timeout = () => tlsSocket.destroy(timeoutError);
-    input.signal?.addEventListener('abort', abort, { once: true });
-    tlsSocket.setTimeout(SOCKS5_HANDSHAKE_TIMEOUT_MS);
-    tlsSocket.once('timeout', timeout);
-    try {
-        await new Promise((resolve, reject) => {
-            const cleanup = () => {
-                tlsSocket.off('secureConnect', connected);
-                tlsSocket.off('error', failed);
-                tlsSocket.off('close', closed);
-            };
-            const connected = () => {
-                cleanup();
-                resolve();
-            };
-            const failed = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const closed = () => {
-                cleanup();
-                reject(Object.assign(new Error('TLS connection closed early.'), { code: 'ECONNRESET' }));
-            };
-            tlsSocket.once('secureConnect', connected);
-            tlsSocket.once('error', failed);
-            tlsSocket.once('close', closed);
-        });
-        tlsSocket.setTimeout(0);
-        tlsSocket.off('timeout', timeout);
-        if (input.requiredAlpnProtocol !== undefined &&
-            tlsSocket.alpnProtocol !== input.requiredAlpnProtocol)
-            throw http2NegotiationError();
-        return tlsSocket;
-    }
-    catch (error) {
-        tlsSocket.destroy();
-        throw error;
-    }
-    finally {
-        tlsSocket.off('timeout', timeout);
-        input.signal?.removeEventListener('abort', abort);
-    }
-}
-function socks5ReplyError(reply) {
-    const code = reply === 0x03
-        ? 'ENETUNREACH'
-        : reply === 0x04
-            ? 'EHOSTUNREACH'
-            : reply === 0x05
-                ? 'ECONNREFUSED'
-                : reply === 0x06
-                    ? 'ETIMEDOUT'
-                    : reply === 0x07
-                        ? 'EPROTONOSUPPORT'
-                        : reply === 0x08
-                            ? 'EAFNOSUPPORT'
-                            : 'EIO';
-    return socks5ProtocolError(code, 'SOCKS5 proxy could not connect to the model endpoint.');
-}
-function socks5ProtocolError(code, message) {
-    return Object.assign(new Error(message), { code });
-}
-function invalidSocks5Proxy(cause) {
-    return new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'SOCKS5 proxy URL is invalid.', {
-        ...(cause === undefined ? {} : { cause })
-    });
-}
-function asError(error) {
-    return error instanceof Error ? error : new Error('Model transport failed.', { cause: error });
-}
-function strictHttp2Connector() {
-    const connector = buildConnector({ allowH2: true });
-    return (options, callback) => connector(options, (error, socket) => {
-        if (error || socket === null) {
-            callback(error, socket);
-            return;
-        }
-        if (!('alpnProtocol' in socket) || socket.alpnProtocol !== 'h2') {
-            const negotiationError = http2NegotiationError();
-            socket.destroy(negotiationError);
-            callback(negotiationError, null);
-            return;
-        }
-        callback(null, socket);
-    });
-}
-function http2NegotiationError() {
-    return Object.assign(new Error('HTTP/2 ALPN negotiation failed.'), {
-        code: 'MAR_AGENT_HTTP2_NEGOTIATION_FAILED'
-    });
-}
-function responseWithDispatcherLifecycle(response, dispatcher) {
-    if (response.body === null) {
-        void dispatcher.close();
-        return response;
-    }
-    const reader = response.body.getReader();
-    let closed = false;
-    const close = async () => {
-        if (closed)
-            return;
-        closed = true;
-        await dispatcher.close().catch(() => undefined);
-    };
-    const body = new ReadableStream({
-        async pull(controller) {
-            try {
-                const result = await reader.read();
-                if (result.done) {
-                    controller.close();
-                    await close();
-                }
-                else
-                    controller.enqueue(result.value);
-            }
-            catch (error) {
-                controller.error(error);
-                await close();
-            }
-        },
-        async cancel(reason) {
-            await reader.cancel(reason).catch(() => undefined);
-            await close();
-        }
-    });
-    return new Response(body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-    });
-}
-function isModelHttpAttempt(value) {
-    return 'request' in value && (value.httpVersion === '1.1' || value.httpVersion === '2');
-}
-function hasErrorCode(error, code) {
-    let current = error;
-    for (let depth = 0; depth < 6 && current !== null && typeof current === 'object'; depth++) {
-        const value = current;
-        if (value.code === code)
-            return true;
-        current = value.cause;
-    }
-    return false;
-}
-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 MarAgentError &&
-        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;
-}
-function isModelConnectionTimeout(error) {
-    return (error instanceof MarAgentError &&
-        error.code === 'MAR_AGENT_MODEL_TIMEOUT' &&
-        error.details?.reason === 'MODEL_CONNECTION_TIMEOUT');
-}
-export function isRetryableModelTransportError(error) {
-    let current = error;
-    for (let depth = 0; depth < 4 && current !== null && typeof current === 'object'; depth++) {
-        const record = current;
-        if (typeof record.code === 'string' && RETRYABLE_TRANSPORT_CODES.has(record.code))
-            return true;
-        current = record.cause;
-    }
-    return false;
-}

package/dist/agent-core/model/image.d.ts

@@ -1,17 +0,0 @@
-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;
-}
-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/agent-core/model/openai-responses.d.ts

@@ -1,77 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { type MarAgentModelConfiguration, type ModelCredentialAcquireReason } from './configuration.js';
-import WebSocket from 'ws';
-import type { ModelAdapter, ModelAttemptDiagnostic, ModelEvent, ModelRequest, ModelTurnSession } from './contracts.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";
-type ResponsesRequestBody = Readonly<Record<string, unknown>> & {
-    readonly input: readonly unknown[];
-};
-interface ResponsesSessionState {
-    socket?: WebSocket;
-    endpoint?: string;
-    credentialRevision?: number;
-    credentialFingerprint?: string;
-    connectionId?: string;
-    proxyType?: 'DIRECT' | 'SOCKS5';
-    lastRequest?: ResponsesRequestBody;
-    lastMessageCount?: number;
-    lastInputItemCount?: number;
-    lastSystem?: string;
-    lastResponse?: {
-        readonly responseId: string;
-        readonly outputItems: readonly Record<string, unknown>[];
-    };
-}
-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: MarAgentModelConfiguration);
-    get configuration(): MarAgentModelConfiguration;
-    prepareReconfigure(configuration: MarAgentModelConfiguration): (() => void) | undefined;
-    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
-    createTurnSession(): ModelTurnSession;
-    close(): Promise<void>;
-    releaseTurnSession(state: ResponsesSessionState, cacheLease: boolean): 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 state;
-    private readonly cacheLease;
-    constructor(adapter: OpenAiResponsesAdapter, state: ResponsesSessionState, cacheLease: boolean);
-    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
-    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: MarAgentModelConfiguration;
-        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 MarAgentError;
-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>[];
-export {};