@myagentroam/agent 0.11.32 → 0.11.34

package/dist/model/anthropic-thinking.js

@@ -0,0 +1,33 @@
+import { AgentError } from '../error.js';
+export const ANTHROPIC_THINKING_LIMITS = {
+    blockBytes: 512 * 1024,
+    contextBytes: 8 * 1024 * 1024
+};
+/** Whitelist opaque protocol state without interpreting or rewriting signed fields. */
+export function anthropicThinkingBlock(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const block = value;
+    const keys = Object.keys(block);
+    let result;
+    if (block.type === 'thinking' &&
+        typeof block.thinking === 'string' &&
+        typeof block.signature === 'string' &&
+        block.signature.length > 0 &&
+        keys.every((key) => ['type', 'thinking', 'signature'].includes(key)))
+        result = { type: 'thinking', thinking: block.thinking, signature: block.signature };
+    else if (block.type === 'redacted_thinking' &&
+        typeof block.data === 'string' &&
+        block.data.length > 0 &&
+        keys.every((key) => ['type', 'data'].includes(key)))
+        result = { type: 'redacted_thinking', data: block.data };
+    else
+        return undefined;
+    return Buffer.byteLength(JSON.stringify(result)) <= ANTHROPIC_THINKING_LIMITS.blockBytes
+        ? result
+        : undefined;
+}
+export function assertAnthropicThinkingBudget(bytes) {
+    if (bytes > ANTHROPIC_THINKING_LIMITS.contextBytes)
+        throw new AgentError('MAR_AGENT_CONTEXT_LIMIT', 'Anthropic native thinking context exceeds its bounded context limit.');
+}

package/dist/model/configuration.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { SecretValue, type ModelCredentialProvider } from '../network/credentials.js';
+export { SecretValue } from '../network/credentials.js';
+export type { ModelCredential, ModelCredentialAcquireReason, ModelCredentialProvider } from '../network/credentials.js';
+export type ResponsesTransport = {
+    readonly transport: 'HTTP';
+    readonly httpVersion: '1.1' | '2';
+} | {
+    readonly transport: 'WEBSOCKET';
+};
+export declare const agentReasoningEffortSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+    ultra: "ultra";
+}>;
+export type AgentReasoningEffort = z.infer<typeof agentReasoningEffortSchema>;
+declare const rawModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    protocol: z.ZodEnum<{
+        OPENAI_RESPONSES: "OPENAI_RESPONSES";
+        ANTHROPIC_MESSAGES: "ANTHROPIC_MESSAGES";
+    }>;
+    baseUrl: z.ZodString;
+    apiKey: z.ZodString;
+    credentialProvider: z.ZodOptional<z.ZodNever>;
+    credential: z.ZodOptional<z.ZodNever>;
+    modelId: z.ZodString;
+    contextWindowTokens: z.ZodNumber;
+    maxOutputTokens: z.ZodNumber;
+    inputCapabilities: z.ZodArray<z.ZodEnum<{
+        TEXT: "TEXT";
+        IMAGE: "IMAGE";
+    }>>;
+    outputCapabilities: z.ZodTuple<[z.ZodLiteral<"TEXT">], null>;
+    reasoningEfforts: z.ZodArray<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+    }>>;
+    defaultReasoningEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+    }>>;
+    conversationModel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    titleGeneration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    useResourceUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fastMode: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        auto: "auto";
+        flex: "flex";
+        priority: "priority";
+        fast: "fast";
+        ultrafast: "ultrafast";
+    }>>;
+    hostedWebSearch: z.ZodBoolean;
+    responsesTransport: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        transport: z.ZodLiteral<"HTTP">;
+        httpVersion: z.ZodEnum<{
+            1.1: "1.1";
+            2: "2";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        transport: z.ZodLiteral<"WEBSOCKET">;
+    }, z.core.$strip>], "transport">>;
+    responsesToolNamespace: z.ZodOptional<z.ZodString>;
+    responsesPreviousResponseId: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    responsesConfigurationUpdates: z.ZodOptional<z.ZodBoolean>;
+    responsesOptionalParameters: z.ZodOptional<z.ZodObject<{
+        reasoningEffort: z.ZodBoolean;
+        reasoningSummary: z.ZodBoolean;
+        textVerbosity: z.ZodBoolean;
+        promptCacheKey: z.ZodBoolean;
+        nativeTools: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export interface AgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'credential' | 'credentialProvider' | 'responsesPreviousResponseId' | 'responsesTransport' | 'conversationModel' | 'useResourceUrl'> {
+    conversationModel?: boolean;
+    useResourceUrl?: boolean;
+    apiKey?: SecretValue;
+    credentialProvider?: ModelCredentialProvider;
+    /** Whether this Responses endpoint accepts native configuration_update input items. */
+    responsesConfigurationUpdates?: boolean;
+    responsesTransport?: ResponsesTransport;
+    responsesPreviousResponseId?: boolean;
+}
+export declare function usesResponsesConfigurationUpdates(model: Pick<AgentModelConfiguration, 'protocol' | 'responsesConfigurationUpdates'>): boolean;
+export interface ModelCatalog {
+    version: 1;
+    defaultModelId?: string;
+    models: readonly AgentModelConfiguration[];
+}
+/** Validate and project a direct SDK model without copying credential objects. */
+export declare function normalizeRuntimeModelConfiguration(input: unknown): AgentModelConfiguration;
+export declare function resolveModelDefaultReasoningEffort(model: Pick<AgentModelConfiguration, 'defaultReasoningEffort' | 'reasoningEfforts'>): AgentReasoningEffort;
+export declare function parseModelCatalog(input: unknown, options?: {
+    allowLoopbackHttp?: boolean;
+}): ModelCatalog;

package/dist/model/configuration.js

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { AgentError } from '../error.js';
+import { SecretValue } from '../network/credentials.js';
+export { SecretValue } from '../network/credentials.js';
+const rawResponsesTransportSchema = z.discriminatedUnion('transport', [
+    z.object({ transport: z.literal('HTTP'), httpVersion: z.enum(['1.1', '2']) }).strip(),
+    z.object({ transport: z.literal('WEBSOCKET') }).strip()
+]);
+export const agentReasoningEffortSchema = z.enum([
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+    'ultra'
+]);
+const modelFieldsSchema = z
+    .object({
+    id: z
+        .string()
+        .min(1)
+        .max(128)
+        .regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
+    name: z.string().trim().min(1).max(128),
+    protocol: z.enum(['OPENAI_RESPONSES', 'ANTHROPIC_MESSAGES']),
+    baseUrl: z.string().url(),
+    apiKey: z.string().min(1).max(16_384),
+    credentialProvider: z.never().optional(),
+    credential: z.never().optional(),
+    modelId: z.string().min(1).max(256),
+    contextWindowTokens: z.number().int().positive(),
+    maxOutputTokens: z.number().int().positive(),
+    inputCapabilities: z.array(z.enum(['TEXT', 'IMAGE'])).min(1),
+    outputCapabilities: z.tuple([z.literal('TEXT')]),
+    reasoningEfforts: z.array(agentReasoningEffortSchema),
+    defaultReasoningEffort: agentReasoningEffortSchema.optional(),
+    conversationModel: z.boolean().optional().default(true),
+    titleGeneration: z.boolean().optional().default(false),
+    codeMode: z.boolean().optional().default(false),
+    useResourceUrl: z.boolean().optional().default(false),
+    fastMode: z.boolean().optional(),
+    serviceTier: z.enum(['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast']).optional(),
+    hostedWebSearch: z.boolean(),
+    responsesTransport: rawResponsesTransportSchema.optional(),
+    responsesToolNamespace: z
+        .string()
+        .regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u)
+        .optional(),
+    responsesPreviousResponseId: z.boolean().optional().default(false),
+    responsesConfigurationUpdates: z.boolean().optional(),
+    responsesOptionalParameters: z
+        .object({
+        reasoningEffort: z.boolean(),
+        reasoningSummary: z.boolean(),
+        textVerbosity: z.boolean(),
+        promptCacheKey: z.boolean(),
+        nativeTools: z.boolean().optional()
+    })
+        .strip()
+        .optional(),
+    enabled: z.boolean()
+})
+    .strip();
+function validateModelFields(value, context) {
+    if (!value.inputCapabilities.includes('TEXT'))
+        context.addIssue({ code: 'custom', message: 'TEXT input capability is required.' });
+    if (value.maxOutputTokens >= value.contextWindowTokens)
+        context.addIssue({
+            code: 'custom',
+            message: 'Output limit must be smaller than context window.'
+        });
+    if (value.protocol === 'ANTHROPIC_MESSAGES' && value.hostedWebSearch)
+        context.addIssue({
+            code: 'custom',
+            message: 'Hosted Web is not declared by the Anthropic Messages compatibility adapter.'
+        });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesPreviousResponseId)
+        context.addIssue({ code: 'custom', message: 'Responses continuation requires Responses.' });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesTransport !== undefined)
+        context.addIssue({ code: 'custom', message: 'Responses transport requires Responses.' });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesConfigurationUpdates !== undefined)
+        context.addIssue({
+            code: 'custom',
+            message: 'Responses configuration updates require Responses.'
+        });
+    if (value.responsesToolNamespace !== undefined && value.protocol !== 'OPENAI_RESPONSES')
+        context.addIssue({
+            code: 'custom',
+            path: ['responsesToolNamespace'],
+            message: 'Tool namespaces require Standard OpenAI Responses.'
+        });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.fastMode === true)
+        context.addIssue({ code: 'custom', message: 'Fast mode requires Responses.' });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.serviceTier !== undefined)
+        context.addIssue({ code: 'custom', message: 'Service tier requires Responses.' });
+}
+const rawModelSchema = modelFieldsSchema
+    .superRefine(validateModelFields)
+    .superRefine((value, context) => {
+    if (value.defaultReasoningEffort !== undefined &&
+        value.reasoningEfforts.length > 0 &&
+        !value.reasoningEfforts.includes(value.defaultReasoningEffort))
+        context.addIssue({
+            code: 'custom',
+            path: ['defaultReasoningEffort'],
+            message: 'Default reasoning effort must be included in the exposed choices.'
+        });
+});
+const runtimeModelSchema = modelFieldsSchema
+    .extend({
+    // The direct SDK API accepts SecretValue or a live provider, not catalog strings.
+    apiKey: z.instanceof(SecretValue).optional(),
+    credentialProvider: z
+        .custom((value) => typeof value === 'object' &&
+        value !== null &&
+        typeof value.acquire === 'function' &&
+        typeof value.invalidate === 'function' &&
+        typeof value.close === 'function')
+        .optional(),
+    // The SDK does not apply the catalog's URL policy to direct model inputs.
+    baseUrl: z.string()
+})
+    .superRefine(validateModelFields)
+    .superRefine((value, context) => {
+    if ((value.apiKey === undefined) === (value.credentialProvider === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Exactly one model credential source is required.'
+        });
+});
+export function usesResponsesConfigurationUpdates(model) {
+    return model.protocol === 'OPENAI_RESPONSES' && model.responsesConfigurationUpdates === true;
+}
+/** Validate and project a direct SDK model without copying credential objects. */
+export function normalizeRuntimeModelConfiguration(input) {
+    const parsed = runtimeModelSchema.safeParse(input);
+    if (!parsed.success)
+        throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model configuration is invalid.', {
+            details: { issues: parsed.error.issues.map((issue) => issue.message) }
+        });
+    const { apiKey, credentialProvider, credential: _credential, responsesTransport, responsesConfigurationUpdates, ...model } = parsed.data;
+    return {
+        ...model,
+        ...(apiKey === undefined ? {} : { apiKey }),
+        ...(credentialProvider === undefined ? {} : { credentialProvider }),
+        ...(responsesTransport === undefined ? {} : { responsesTransport }),
+        ...(responsesConfigurationUpdates === undefined ? {} : { responsesConfigurationUpdates })
+    };
+}
+export function resolveModelDefaultReasoningEffort(model) {
+    const configured = agentReasoningEffortSchema.safeParse(model.defaultReasoningEffort);
+    if (configured.success &&
+        (model.reasoningEfforts.length === 0 || model.reasoningEfforts.includes(configured.data)))
+        return configured.data;
+    return model.reasoningEfforts.includes('medium')
+        ? 'medium'
+        : (model.reasoningEfforts[0] ?? 'medium');
+}
+export function parseModelCatalog(input, options = {}) {
+    const catalogSchema = z.object({
+        version: z.literal(1),
+        defaultModelId: z.string().optional(),
+        models: z.array(rawModelSchema)
+    });
+    const parsed = catalogSchema.safeParse(input);
+    if (!parsed.success)
+        throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model catalog is invalid.', {
+            details: { issues: parsed.error.issues.map((issue) => issue.message) }
+        });
+    const ids = new Set();
+    const names = new Set();
+    for (const model of parsed.data.models) {
+        const url = new URL(model.baseUrl);
+        const loopback = url.hostname === '127.0.0.1' || url.hostname === 'localhost' || url.hostname === '::1';
+        if (url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            (url.protocol !== 'https:' && !(options.allowLoopbackHttp && loopback)))
+            throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model base URL is not allowed.');
+        const normalizedName = model.name.normalize('NFKC').toLocaleLowerCase('en-US');
+        if (ids.has(model.id) || names.has(normalizedName))
+            throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model identifiers and names must be unique.');
+        ids.add(model.id);
+        names.add(normalizedName);
+    }
+    if (parsed.data.defaultModelId !== undefined && !ids.has(parsed.data.defaultModelId))
+        throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default model does not exist.');
+    return {
+        version: 1,
+        ...(parsed.data.defaultModelId === undefined
+            ? {}
+            : { defaultModelId: parsed.data.defaultModelId }),
+        models: parsed.data.models.map(({ apiKey, responsesTransport, responsesConfigurationUpdates, credentialProvider: _provider, credential: _credential, ...model }) => ({
+            ...model,
+            apiKey: new SecretValue(apiKey),
+            ...(responsesConfigurationUpdates === undefined ? {} : { responsesConfigurationUpdates }),
+            ...(responsesTransport === undefined ? {} : { responsesTransport })
+        }))
+    };
+}

package/dist/model/contracts.d.ts

@@ -0,0 +1,229 @@
+import type { ModelUsage } from './usage.js';
+export type { ModelUsage } from './usage.js';
+import type { ModelImage } from './image.js';
+import type { AgentModelConfiguration, AgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
+export interface ModelToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    nativeType?: 'tool_search';
+    inputMode?: 'json' | 'freeform';
+}
+export type ModelContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    image: ModelImage;
+};
+export interface ModelTextBlock {
+    readonly text: string;
+    readonly cache?: true;
+}
+export interface ModelInputMetadata {
+    source: 'user' | 'parent_agent' | 'extension';
+    recordId?: string;
+    extensionId?: string;
+    truncated?: true;
+    smartCompaction?: true;
+}
+/** SDK-owned provenance. Text labels never grant instruction authority. */
+export interface ModelContextualBlock {
+    id: string;
+    kind: string;
+    source: 'sdk' | 'host' | 'extension' | 'runtime';
+    authority: 'instruction' | 'context';
+    revision: string;
+    operation: 'replace' | 'remove';
+}
+export interface ModelMessage {
+    /** Model-facing tool-result status; independent of the actual execution outcome. */
+    isError?: boolean;
+    role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
+    content: string;
+    textBlocks?: readonly ModelTextBlock[];
+    contentParts?: readonly ModelContentPart[];
+    contextKind?: 'environment' | 'private' | 'contextual' | 'summary' | 'compact_control';
+    contextualBlock?: ModelContextualBlock;
+    /** Input provenance and local truncation state; never serialized to a Provider. */
+    metadata?: ModelInputMetadata;
+    callId?: string;
+    name?: string;
+    arguments?: unknown;
+    /** Definitions returned by a successful Tool Search output. */
+    toolSearchTools?: readonly ModelToolDefinition[];
+    inputMode?: 'json' | 'freeform';
+    provider?: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';
+    providerModelId?: string;
+    item?: Record<string, unknown>;
+    images?: readonly ModelImage[];
+}
+export interface ModelAttemptDiagnostic {
+    protocol: AgentModelConfiguration['protocol'];
+    transport: 'HTTP' | 'WEBSOCKET';
+    state: 'STARTED' | 'SUCCEEDED' | 'FAILED';
+    attempt: number;
+    maxAttempts: number;
+    continuation: boolean;
+    credentialReason: ModelCredentialAcquireReason;
+    semanticEventObserved?: boolean;
+    firstSemanticEventType?: ModelEvent['type'];
+    connectionId?: string;
+    connectionReused?: boolean;
+    proxyType?: 'DIRECT' | 'SOCKS5';
+    /** Item count of the lowered full logical request, not just a continuation suffix. */
+    requestInputItems?: number;
+    /** Actual serialized WebSocket request size, including inline image Base64. */
+    requestBytes?: number;
+    imageCount?: number;
+    /** Decoded byte count of inline input images; external URLs do not add bytes. */
+    imageBytes?: number;
+    requestFrameCount?: number;
+    sentFrameCount?: number;
+    webSocketPhase?: 'CONNECT' | 'SEND' | 'RECEIVE';
+    webSocketCloseCode?: number;
+    durationMs?: number;
+    errorCode?: string;
+    errorMessage?: string;
+    causeCode?: string;
+    reason?: string;
+    retryable?: boolean;
+    willRetry?: boolean;
+    retryDelayMs?: number;
+    retryReason?: 'INVALID_CONTINUATION' | 'UNAUTHORIZED' | 'STREAM';
+}
+export interface ModelRetryState {
+    attempts: number;
+    readonly maxAttempts?: number;
+    retryDelayMs?: number;
+}
+export interface ModelRequest {
+    /** Metering identity and sink are local only, never serialized upstream. */
+    usageRequestId?: string;
+    onModelUsage?: (usage: import('./usage.js').ModelRequestUsage) => Promise<void> | void;
+    onModelUsageFailure?: () => void;
+    /** Shared local attempt accounting across Adapter retries and Runtime continuation. Never sent upstream. */
+    retryState?: ModelRetryState;
+    system: string;
+    systemBlocks?: readonly ModelTextBlock[];
+    /** Retain the automatic cache boundary of an actual captured prefix, excluding a fork tail. */
+    cachePrefixMessages?: number;
+    messages: readonly ModelMessage[];
+    tools: readonly ModelToolDefinition[];
+    /** Optional per-request cap; adapters never exceed their configured output ceiling. */
+    outputLimit?: number;
+    allowTools?: boolean;
+    /** Neutral capability intersection; excludes provider-executed tools when false. */
+    allowHostedTools?: boolean;
+    /** Preserve the visible tool catalog while controlling whether the model may call it. */
+    toolChoice?: 'auto' | 'none';
+    reasoningEffort?: AgentReasoningEffort;
+    /** Stable request-level effort while native configuration updates select the current effort. */
+    requestReasoningEffort?: AgentReasoningEffort;
+    promptCacheKey?: string;
+    images?: readonly ModelImage[];
+    /** Awaited by the request; cancel via its signal rather than awaiting a close that joins it. */
+    onAttemptDiagnostic?: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void;
+}
+export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output' | 'cancelled';
+export type ModelEvent = {
+    type: 'response.started';
+    responseId: string;
+    modelId?: string;
+} | {
+    type: 'output.started';
+} | {
+    type: 'output.delta';
+} | {
+    type: 'output.paused';
+} | {
+    type: 'output.completed';
+} | {
+    type: 'output.reset';
+} | {
+    type: 'response.item';
+    provider: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';
+    contextKind?: ModelMessage['contextKind'];
+    item: Record<string, unknown>;
+} | {
+    type: 'text.delta';
+    itemId: string;
+    phase: 'commentary' | 'final_answer';
+    delta: string;
+} | {
+    type: 'text.completed';
+    itemId: string;
+    phase?: 'commentary' | 'final_answer';
+    text: string;
+} | {
+    type: 'reasoning.completed';
+    itemId: string;
+    representation: 'summary' | 'visible_thinking' | 'unspecified';
+    text: string;
+} | {
+    type: 'client_tool.call';
+    callId: string;
+    name: string;
+    arguments: unknown;
+    argumentError?: string;
+    inputMode?: 'json' | 'freeform';
+} | {
+    type: 'hosted_tool';
+    itemId: string;
+    kind: 'WEB_SEARCH' | 'WEB_FETCH';
+    status: 'RUNNING' | 'COMPLETED' | 'FAILED';
+    toolName?: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+    truncated?: boolean;
+    summary: {
+        query?: string | undefined;
+        url?: string | undefined;
+        title?: string | undefined;
+        sources?: readonly {
+            url: string;
+            title?: string | undefined;
+            snippet?: string | undefined;
+        }[] | undefined;
+        sourcesTruncated?: boolean | undefined;
+    };
+} | {
+    type: 'citation';
+    citation: {
+        id: string;
+        url: string;
+        title?: string | undefined;
+        start?: number | undefined;
+        end?: number | undefined;
+    };
+} | {
+    type: 'usage';
+    usage: ModelUsage;
+    final?: boolean;
+} | {
+    type: 'unknown';
+    nativeType: string;
+} | {
+    type: 'completed';
+    reason: ModelStopReason;
+};
+export interface ModelAdapter {
+    readonly configuration: AgentModelConfiguration;
+    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
+    createTurnSession?(): ModelTurnSession;
+    /**
+     * Prepares an equivalent model rebind without mutating live state.
+     * The returned commit callback must be synchronous and non-throwing.
+     */
+    prepareReconfigure?(configuration: AgentModelConfiguration): (() => void) | undefined;
+    close?(): Promise<void>;
+}
+export interface ModelTurnSession {
+    start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
+    /** Drops incremental response state after a local context replacement. */
+    resetContinuation?(): void;
+    continuationInputCount?(): number;
+    commitContinuationInput?(messageCount: number): void;
+    /** Cancels and joins active requests. An awaited request callback must not await this barrier. */
+    close(): Promise<void>;
+}

package/dist/model/http.d.ts

@@ -0,0 +1,13 @@
+export { isRetryableTransportError as isRetryableModelTransportError } from '../network/transport-error.js';
+import { AgentError } from '../error.js';
+import { connectSocks5Target as connectTransportSocks5Target, type HttpRequestInit } from '../network/http.js';
+import type { ModelRetryState } from './contracts.js';
+export declare const MAX_MODEL_ATTEMPTS = 8;
+export declare function modelRetryMaxAttempts(state: ModelRetryState): number;
+export type { HttpAttempt, HttpRequestInit } from '../network/http.js';
+export declare function connectSocks5Target(input: Parameters<typeof connectTransportSocks5Target>[0]): ReturnType<typeof connectTransportSocks5Target>;
+export declare function fetchModelResponse(url: string, init: HttpRequestInit, signal: AbortSignal, attempts?: number, connectionTimeoutMs?: number): Promise<Response>;
+export declare function modelRetryDelay(retryAfter: string | null, attempt: number): number;
+export declare function waitForModelRetry(retryAfter: string | null, attempt: number, signal: AbortSignal, delayMs?: number): Promise<void>;
+export declare function isRetryableModelHttpStatus(status: number): boolean;
+export declare function isRetryableModelRequestError(error: unknown): error is AgentError;