@myagentroam/agent 0.11.20 → 0.11.22

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

@@ -9,7 +9,7 @@ export declare class MarAgentError extends Error {
         cause?: unknown;
     });
 }
-export declare function describeMarAgentError(error: unknown, fallbackCode: string, fallbackMessage?: string): {
+export declare function describeMarAgentError(error: unknown, fallbackCode: string, fallbackMessage?: string, includeCauses?: boolean): {
     code: string;
     message: string;
 };

package/dist/agent-core/error.js

@@ -13,7 +13,7 @@ export class MarAgentError extends Error {
     }
 }
 const MAX_ERROR_MESSAGE_CHARACTERS = 1_000;
-export function describeMarAgentError(error, fallbackCode, fallbackMessage = 'MAR Agent operation failed.') {
+export function describeMarAgentError(error, fallbackCode, fallbackMessage = 'MAR Agent operation failed.', includeCauses = true) {
     const code = diagnosticCode(error) ?? fallbackCode;
     const messages = [];
     const seen = new Set();
@@ -22,8 +22,13 @@ export function describeMarAgentError(error, fallbackCode, fallbackMessage = 'MA
         seen.add(current);
         const currentCode = diagnosticCode(current);
         const message = diagnosticMessage(current, currentCode);
-        if (message && !messages.includes(message))
-            messages.push(message);
+        const summary = message && currentCode !== undefined && currentCode !== code
+            ? `${currentCode}: ${message}`
+            : message;
+        if (summary && !messages.includes(summary))
+            messages.push(summary);
+        if (!includeCauses)
+            break;
         current = diagnosticCause(current);
     }
     return {
@@ -40,23 +45,24 @@ function diagnosticCode(value) {
     return typeof code === 'string' && code.trim().length > 0 ? code.trim().slice(0, 80) : undefined;
 }
 function diagnosticMessage(value, code) {
-    const message = value instanceof Error
-        ? value.message
-        : value !== null &&
-            typeof value === 'object' &&
-            'message' in value &&
-            typeof value.message === 'string'
+    const message = value instanceof MarAgentError
+        ? value.publicMessage
+        : value instanceof Error
             ? value.message
-            : typeof value === 'string'
-                ? value
-                : undefined;
+            : value !== null &&
+                typeof value === 'object' &&
+                'message' in value &&
+                typeof value.message === 'string'
+                ? value.message
+                : typeof value === 'string'
+                    ? value
+                    : undefined;
     const normalized = message?.trim();
     if (!normalized)
         return undefined;
-    const withoutDuplicatedCode = code !== undefined && normalized.startsWith(`${code}: `)
+    return code !== undefined && normalized.startsWith(`${code}: `)
         ? normalized.slice(code.length + 2)
         : normalized;
-    return code === undefined ? withoutDuplicatedCode : `${code}: ${withoutDuplicatedCode}`;
 }
 function diagnosticCause(value) {
     if (value === null || typeof value !== 'object' || !('cause' in value))

package/dist/agent-core/extensions/compaction.d.ts

@@ -10,6 +10,12 @@ export interface CoreCompactDiagnostic {
     readonly elapsedMs: number;
     readonly reason?: 'INPUT_BUDGET_EXHAUSTED' | 'MODEL_INCOMPLETE' | 'MODEL_FAILED';
     readonly errorCode?: string;
+    readonly trigger?: 'manual' | 'automatic';
+    readonly causeCode?: string;
+    readonly errorReason?: string;
+    readonly httpStatus?: number;
+    readonly retryable?: boolean;
+    readonly transport?: 'HTTP' | 'WEBSOCKET';
 }
 export interface CoreCompactMessage {
     readonly role: 'user' | 'assistant' | 'tool' | 'tool_call';

package/dist/agent-core/extensions/compaction.js

@@ -35,6 +35,7 @@ export function compactExtensionDiagnostic(value) {
         value.length > 0 &&
         value.length <= limit &&
         !/[\r\n]/u.test(value);
+    const code = (value) => typeof value === 'string' && /^[A-Za-z][A-Za-z0-9_.-]{0,127}$/u.test(value);
     if (!label(input.modelId, 128) ||
         !label(input.reasoningEffort, 32) ||
         typeof input.state !== 'string' ||
@@ -61,8 +62,21 @@ export function compactExtensionDiagnostic(value) {
             ['INPUT_BUDGET_EXHAUSTED', 'MODEL_INCOMPLETE', 'MODEL_FAILED'].includes(input.reason)
             ? { reason: input.reason }
             : {}),
-        ...(typeof input.errorCode === 'string' && /^[A-Z][A-Z0-9_]{0,127}$/u.test(input.errorCode)
-            ? { errorCode: input.errorCode }
+        ...(code(input.errorCode) ? { errorCode: input.errorCode } : {}),
+        ...(input.trigger === 'manual' || input.trigger === 'automatic'
+            ? { trigger: input.trigger }
+            : {}),
+        ...(code(input.causeCode) ? { causeCode: input.causeCode } : {}),
+        ...(code(input.errorReason) ? { errorReason: input.errorReason } : {}),
+        ...(typeof input.httpStatus === 'number' &&
+            Number.isInteger(input.httpStatus) &&
+            input.httpStatus >= 100 &&
+            input.httpStatus <= 599
+            ? { httpStatus: input.httpStatus }
+            : {}),
+        ...(typeof input.retryable === 'boolean' ? { retryable: input.retryable } : {}),
+        ...(input.transport === 'HTTP' || input.transport === 'WEBSOCKET'
+            ? { transport: input.transport }
             : {})
     };
 }

package/dist/agent-core/extensions/model-request.d.ts

@@ -13,10 +13,7 @@ export type CoreModelMessage = {
     readonly callId?: string;
     readonly name?: string;
     readonly arguments?: unknown;
-    readonly images?: readonly {
-        readonly mimeType: string;
-        readonly dataBase64: string;
-    }[];
+    readonly images?: readonly import('../model/image.js').ModelImage[];
 };
 export interface CoreModelRequest {
     readonly modelId: string;
@@ -26,10 +23,7 @@ export interface CoreModelRequest {
     readonly tools: readonly ClientToolDefinition[];
     readonly toolChoice?: 'auto' | 'none';
     readonly reasoningEffort?: MarAgentReasoningEffort;
-    readonly images?: readonly {
-        readonly mimeType: string;
-        readonly dataBase64: string;
-    }[];
+    readonly images?: readonly import('../model/image.js').ModelImage[];
 }
 export interface CoreRequestSnapshot {
     readonly id: string;
@@ -54,7 +48,9 @@ export declare class ExtensionRequestBridge {
     #private;
     readonly modelId: string;
     readonly original: ModelRequest;
+    private readonly committedPrefix;
+    rewroteCommittedInput: boolean;
     readonly view: CoreModelRequest;
-    constructor(modelId: string, original: ModelRequest, sourceMessages?: readonly CoreModelMessage[]);
+    constructor(modelId: string, original: ModelRequest, sourceMessages?: readonly CoreModelMessage[], committedPrefix?: number);
     lower(view: CoreModelRequest): ModelRequest;
 }

package/dist/agent-core/extensions/model-request.js

@@ -59,11 +59,14 @@ function freezeSnapshot(value) {
 export class ExtensionRequestBridge {
     modelId;
     original;
+    committedPrefix;
     #messages = new Map();
+    rewroteCommittedInput = false;
     view;
-    constructor(modelId, original, sourceMessages) {
+    constructor(modelId, original, sourceMessages, committedPrefix = 0) {
         this.modelId = modelId;
         this.original = original;
+        this.committedPrefix = committedPrefix;
         const messages = original.messages.map((original, index) => {
             const sourceRef = sourceMessages?.[index]?.sourceRef ?? randomUUID();
             const view = original.role === 'provider'
@@ -82,7 +85,7 @@ export class ExtensionRequestBridge {
                         : {}),
                     ...(original.images !== undefined ? { images: structuredClone(original.images) } : {})
                 };
-            this.#messages.set(sourceRef, { original, view: structuredClone(view) });
+            this.#messages.set(sourceRef, { original, view: structuredClone(view), index });
             return view;
         });
         this.view = {
@@ -113,7 +116,11 @@ export class ExtensionRequestBridge {
                 Array.isArray(tool.inputSchema)))
             throw new MarAgentError('MAR_AGENT_EXTENSION_MODEL_REQUEST_INVALID', 'Model request view is invalid.');
         const seen = new Set();
-        const messages = view.messages.map((message) => {
+        if (view.messages.length < this.committedPrefix ||
+            view.system !== this.original.system ||
+            !isDeepStrictEqual(view.systemBlocks, this.original.systemBlocks))
+            this.rewroteCommittedInput = true;
+        const messages = view.messages.map((message, index) => {
             if (!message || typeof message !== 'object')
                 throw new MarAgentError('MAR_AGENT_EXTENSION_MODEL_REQUEST_INVALID', 'Message view is invalid.');
             const source = message.sourceRef ? this.#messages.get(message.sourceRef) : undefined;
@@ -122,8 +129,12 @@ export class ExtensionRequestBridge {
                     throw new MarAgentError('MAR_AGENT_EXTENSION_MODEL_REQUEST_INVALID', 'Message source reference is invalid.');
                 seen.add(message.sourceRef);
             }
+            if (index < this.committedPrefix && source?.index !== index)
+                this.rewroteCommittedInput = true;
             if (source && isDeepStrictEqual(message, source.view))
                 return source.original;
+            if (index < this.committedPrefix)
+                this.rewroteCommittedInput = true;
             if (message.role === 'opaque' ||
                 typeof message.content !== 'string' ||
                 !['user', 'assistant', 'tool', 'tool_call'].includes(message.role))

package/dist/agent-core/extensions/prompt-input.js

@@ -1,4 +1,5 @@
 import { MarAgentError } from '../error.js';
+import { isModelImageUrl } from '../model/image.js';
 export function captureCorePromptInput(input) {
     if (!input ||
         typeof input.text !== 'string' ||
@@ -14,7 +15,8 @@ export function captureCorePromptInput(input) {
                 !Array.from(input.images).every((image) => image &&
                     typeof image.name === 'string' &&
                     typeof image.mimeType === 'string' &&
-                    typeof image.dataBase64 === 'string'))))
+                    typeof image.dataBase64 === 'string' &&
+                    (image.url === undefined || isModelImageUrl(image.url))))))
         throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Prompt content is invalid.');
     return structuredClone({
         text: input.text,

package/dist/agent-core/host/contracts.d.ts

@@ -55,6 +55,14 @@ export interface HostSessionResourceSnapshot {
 export interface MarAgentHost {
     /** Independent model consumption facts, including child and auxiliary calls. */
     modelUsage?: import('../model/usage-observer.js').ModelUsageObserver | undefined;
+    publishModelResource?: (image: import('../session/store/resources.js').SessionResource, context: {
+        sessionId: string;
+        executionId: string;
+        homeDirectory: string;
+    }) => Promise<{
+        url: string;
+        urlExpiresAt: number;
+    } | undefined>;
     readonly extensionPorts?: CoreHostExtensionPorts;
     describe(): Promise<HostDescription>;
     executeTool(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;

package/dist/agent-core/host/local-agent-host.d.ts

@@ -27,6 +27,7 @@ export declare class LocalAgentHost implements MarAgentHost {
     readonly extensionPorts: import('./contracts.js').CoreHostExtensionPorts;
     readonly events: MarAgentEvent[];
     readonly requestToolApproval: MarAgentHost['requestToolApproval'];
+    readonly publishModelResource?: NonNullable<MarAgentHost['publishModelResource']>;
     constructor(input: {
         mcp?: import('../extensions/mcp.js').CoreMcpBackend;
         operationTools?: CoreHostToolsBackend;
@@ -34,6 +35,7 @@ export declare class LocalAgentHost implements MarAgentHost {
         callMcpOperation?: (input: ToolCall, call: CoreOperationContext, expected: NonNullable<McpToolCallContext['expectedTool']>) => Promise<ToolExecutionResult>;
         network?: CoreNetworkBackend | false;
         modelUsage?: import('../model/usage-observer.js').ModelUsageObserver;
+        publishModelResource?: MarAgentHost['publishModelResource'];
         homeDirectory: string;
         workspace: string;
         mode?: 'normal' | 'node';

package/dist/agent-core/host/local-agent-host.js

@@ -32,6 +32,7 @@ export class LocalAgentHost {
     #extensions;
     events = [];
     requestToolApproval;
+    publishModelResource;
     #mode;
     #environment;
     #sessionEnvironment;
@@ -41,6 +42,8 @@ export class LocalAgentHost {
     constructor(input) {
         this.modelUsage = input.modelUsage;
         this.requestToolApproval = input.approval;
+        if (input.publishModelResource !== undefined)
+            this.publishModelResource = input.publishModelResource;
         this.#home = resolve(input.homeDirectory);
         this.#workspace = resolve(input.workspace);
         this.#environment = input.environment ?? process.env;

package/dist/agent-core/model/anthropic-messages.js

@@ -1,9 +1,11 @@
 import { observeModelRequestUsage } from './usage-observer.js';
 import { jsonToolInput } from './tool-input.js';
 import { observationModelParts } from '../tools/code-mode/observations.js';
+import { modelImageKey, modelImageUrl } from './image.js';
 import { stableToolSchema } from '../tools/definition-projection.js';
 import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
+import { assertInlineMediaBudget } from '../session/inline-media.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
 import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
 import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError, isRetryableModelTransportError, modelRetryDelay, waitForModelRetry } from './http.js';
@@ -93,6 +95,7 @@ export class AnthropicMessagesAdapter {
         }
     }
     async *startAttempt(request, signal) {
+        assertInlineMediaBudget(request);
         const apiKey = this.configuration.apiKey;
         if (apiKey === undefined)
             throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Anthropic Messages requires a static API key.');
@@ -588,22 +591,14 @@ function anthropicMessages(messages, images, tools = [], modelId, automaticCache
                     ? { type: 'text', text: part.text }
                     : {
                         type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: part.image.mimeType,
-                            data: part.image.dataBase64
-                        }
+                        source: anthropicImageSource(part.image)
                     }) ??
                     (message.textBlocks !== undefined
                         ? [
                             ...anthropicTextBlocks(message.content, message.textBlocks),
                             ...(message.images ?? []).map((image) => ({
                                 type: 'image',
-                                source: {
-                                    type: 'base64',
-                                    media_type: image.mimeType,
-                                    data: image.dataBase64
-                                }
+                                source: anthropicImageSource(image)
                             }))
                         ]
                         : message.images?.length
@@ -611,11 +606,7 @@ function anthropicMessages(messages, images, tools = [], modelId, automaticCache
                                 { type: 'text', text: message.content },
                                 ...message.images.map((image) => ({
                                     type: 'image',
-                                    source: {
-                                        type: 'base64',
-                                        media_type: image.mimeType,
-                                        data: image.dataBase64
-                                    }
+                                    source: anthropicImageSource(image)
                                 }))
                             ]
                             : message.content)
@@ -646,11 +637,7 @@ function anthropicMessages(messages, images, tools = [], modelId, automaticCache
                 ? [
                     ...userImages.map((image) => ({
                         type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: image.mimeType,
-                            data: image.dataBase64
-                        }
+                        source: anthropicImageSource(image)
                     })),
                     ...anthropicTextBlocks(message.content, message.textBlocks)
                 ]
@@ -658,11 +645,7 @@ function anthropicMessages(messages, images, tools = [], modelId, automaticCache
                     ? [
                         ...userImages.map((image) => ({
                             type: 'image',
-                            source: {
-                                type: 'base64',
-                                media_type: image.mimeType,
-                                data: image.dataBase64
-                            }
+                            source: anthropicImageSource(image)
                         })),
                         { type: 'text', text: message.content }
                     ]
@@ -690,13 +673,19 @@ function isRealUserMessage(message) {
 function uniqueModelImages(...groups) {
     const seen = new Set();
     return groups.flatMap((group) => (group ?? []).flatMap((image) => {
-        const key = `${image.mimeType}\u0000${image.dataBase64}`;
+        const key = modelImageKey(image);
         if (seen.has(key))
             return [];
         seen.add(key);
         return [image];
     }));
 }
+function anthropicImageSource(image) {
+    const url = modelImageUrl(image);
+    return url === image.url
+        ? { type: 'url', url }
+        : { type: 'base64', media_type: image.mimeType, data: image.dataBase64 };
+}
 function isObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/agent-core/model/catalog-file.d.ts

@@ -12,6 +12,7 @@ export declare function writeModelCatalog(home: string, catalog: CliModelCatalog
 export declare function serializeModel(model: CliModelConfiguration): {
     apiKey: string;
     conversationModel?: boolean;
+    useResourceUrl?: boolean;
     responsesConfigurationUpdates?: boolean;
     codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;
@@ -46,6 +47,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
         type: "CODEX_AUTH_FILE";
     };
     conversationModel?: boolean;
+    useResourceUrl?: boolean;
     responsesConfigurationUpdates?: boolean;
     codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;

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

@@ -70,6 +70,7 @@ declare const rawModelSchema: z.ZodObject<{
     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";
@@ -100,8 +101,9 @@ declare const rawModelSchema: z.ZodObject<{
     }, z.core.$strict>>;
     enabled: z.ZodBoolean;
 }, z.core.$strict>;
-export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport' | 'conversationModel'> {
+export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport' | 'conversationModel' | 'useResourceUrl'> {
     conversationModel?: boolean;
+    useResourceUrl?: boolean;
     apiKey?: SecretValue;
     credentialProvider?: ModelCredentialProvider;
     /** Whether this Responses endpoint accepts native configuration_update input items. */

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

@@ -50,6 +50,7 @@ const rawModelSchema = z
     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(),

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

@@ -1,4 +1,5 @@
 import type { ClientToolDefinition } from '../tools/contracts.js';
+import type { ModelImage } from './image.js';
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
 export type { ClientToolDefinition, ToolCaller } from '../tools/contracts.js';
 export interface ModelTextBlock {
@@ -41,10 +42,7 @@ export interface ModelMessage {
     provider?: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';
     providerModelId?: string;
     item?: Record<string, unknown>;
-    images?: readonly {
-        mimeType: string;
-        dataBase64: string;
-    }[];
+    images?: readonly ModelImage[];
     observations?: readonly import('../tools/code-mode/observations.js').CodeObservation[];
     /** Runtime-only location used by the GC evidence adapter, never a Provider call. */
     observationId?: string;
@@ -112,10 +110,7 @@ export interface ModelRequest {
     /** Stable request-level effort while native configuration updates select the current effort. */
     requestReasoningEffort?: MarAgentReasoningEffort;
     promptCacheKey?: string;
-    images?: readonly {
-        mimeType: string;
-        dataBase64: string;
-    }[];
+    images?: readonly ModelImage[];
     onAttemptDiagnostic?: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void;
 }
 export interface ModelUsage {
@@ -228,5 +223,7 @@ 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;
     close(): Promise<void>;
 }

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

@@ -0,0 +1,17 @@
+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/image.js

@@ -0,0 +1,53 @@
+export function modelImageUrl(image) {
+    if (image.url !== undefined && isModelImageUrl(image.url))
+        return image.url;
+    if (typeof image.dataBase64 !== 'string' || image.dataBase64.length === 0)
+        throw new Error('Model image has no usable source.');
+    return `data:${image.mimeType};base64,${image.dataBase64}`;
+}
+export function modelImageKey(image) {
+    return `${image.mimeType}\u0000${modelImageUrl(image)}`;
+}
+/** Only immutable URL references may enter durable model history. */
+export function persistedModelImages(images) {
+    return (images ?? [])
+        .filter((image) => isModelImageUrl(image.url) || image.resourceId !== undefined)
+        .map((image) => ({
+        resourceInputVersion: 1,
+        mimeType: image.mimeType,
+        ...(image.url === undefined ? {} : { url: image.url }),
+        ...(image.urlExpiresAt === undefined ? {} : { urlExpiresAt: image.urlExpiresAt }),
+        ...(image.resourceId === undefined ? {} : { resourceId: image.resourceId }),
+        ...(image.byteSize === undefined ? {} : { byteSize: image.byteSize })
+    }));
+}
+/** Durable images contain a URL or resource reference, never inline image bytes. */
+export function parseModelImages(value) {
+    if (!Array.isArray(value) ||
+        !value.every((image) => image &&
+            image.resourceInputVersion === 1 &&
+            typeof image.mimeType === 'string' &&
+            (image.url === undefined || isModelImageUrl(image.url)) &&
+            (image.resourceId === undefined ||
+                (typeof image.resourceId === 'string' && /^[a-f0-9]{64}$/u.test(image.resourceId))) &&
+            (image.byteSize === undefined ||
+                (Number.isSafeInteger(image.byteSize) && image.byteSize > 0)) &&
+            (image.urlExpiresAt === undefined ||
+                (Number.isSafeInteger(image.urlExpiresAt) && image.urlExpiresAt > 0)) &&
+            (image.url !== undefined || image.resourceId !== undefined)))
+        return undefined;
+    return persistedModelImages(value);
+}
+export function isModelImageUrl(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 8192)
+        return false;
+    try {
+        const url = new URL(value);
+        return ((url.protocol === 'https:' || url.protocol === 'http:') &&
+            url.username === '' &&
+            url.password === '');
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -15,12 +15,16 @@ interface ResponsesSessionState {
     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;
@@ -47,9 +51,10 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     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;
-    fullRequestBody(): ResponsesRequestBody;
     currentTurnState(): string | undefined;
     beginAttempt(): void;
     captureWebSocketDiagnostic(diagnostic: ResponsesWebSocketDiagnostic): void;
@@ -68,5 +73,5 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     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']): Record<string, unknown>[];
+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 {};