@myagentroam/agent 0.9.83 → 0.9.84

package/dist/model/contracts.d.ts

@@ -1,4 +1,13 @@
 import type { MarAgentModelConfiguration, MarAgentReasoningEffort, ModelCredentialAcquireReason } from './configuration.js';
+export interface ModelContinuationCheckpoint {
+    readonly version: 1;
+    readonly protocol: 'OPENAI_RESPONSES';
+    readonly configurationHash: string;
+    readonly responseId: string;
+    readonly requestPropertiesHash: string;
+    readonly inputPrefixLength: number;
+    readonly inputPrefixHash: string;
+}
 export interface ClientToolDefinition {
     name: string;
     description: string;
@@ -11,7 +20,7 @@ export interface ClientToolDefinition {
 export interface ModelMessage {
     role: 'user' | 'assistant' | 'tool' | 'tool_call' | 'provider';
     content: string;
-    contextKind?: 'environment';
+    contextKind?: 'environment' | 'private';
     callId?: string;
     name?: string;
     arguments?: unknown;
@@ -146,11 +155,18 @@ export interface ModelAdapter {
     readonly configuration: MarAgentModelConfiguration;
     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: MarAgentModelConfiguration): (() => void) | undefined;
+    restoreContinuation?(checkpoint: ModelContinuationCheckpoint): boolean;
     close?(): Promise<void>;
 }
 export interface ModelTurnSession {
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     /** Drops incremental response state after a local context replacement. */
     resetContinuation?(): void;
+    continuationCheckpoint?(): ModelContinuationCheckpoint | undefined;
     close(): Promise<void>;
 }

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

@@ -1,7 +1,7 @@
 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';
+import type { ModelAdapter, ModelAttemptDiagnostic, ModelContinuationCheckpoint, 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>> & {
@@ -11,6 +11,7 @@ interface ResponsesSessionState {
     socket?: WebSocket;
     endpoint?: string;
     credentialRevision?: number;
+    credentialFingerprint?: string;
     connectionId?: string;
     proxyType?: 'DIRECT' | 'SOCKS5';
     lastRequest?: ResponsesRequestBody;
@@ -18,18 +19,20 @@ interface ResponsesSessionState {
         readonly responseId: string;
         readonly outputItems: readonly Record<string, unknown>[];
     };
+    restoredContinuation?: ModelContinuationCheckpoint;
 }
 interface PreparedResponsesRequest {
     readonly fullBody: ResponsesRequestBody;
     readonly body: ResponsesRequestBody;
     readonly continuation: boolean;
-    readonly requiresExistingSocket: boolean;
 }
 export declare class OpenAiResponsesAdapter implements ModelAdapter {
     #private;
-    readonly configuration: MarAgentModelConfiguration;
     readonly prefixIdentity: `${string}-${string}-${string}-${string}-${string}`;
     constructor(configuration: MarAgentModelConfiguration);
+    get configuration(): MarAgentModelConfiguration;
+    prepareReconfigure(configuration: MarAgentModelConfiguration): (() => void) | undefined;
+    restoreContinuation(checkpoint: ModelContinuationCheckpoint): boolean;
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     createTurnSession(): ModelTurnSession;
     close(): Promise<void>;
@@ -47,6 +50,7 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     start(request: ModelRequest, signal: AbortSignal): AsyncIterable<ModelEvent>;
     close(): Promise<void>;
     resetContinuation(): void;
+    continuationCheckpoint(): ModelContinuationCheckpoint | undefined;
     prepareRequest(request: ModelRequest): PreparedResponsesRequest;
     fullRequestBody(): ResponsesRequestBody;
     currentTurnState(): string | undefined;
@@ -61,7 +65,6 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
         readonly reason: ModelCredentialAcquireReason;
         readonly signal: AbortSignal;
         readonly continuation: boolean;
-        readonly requiresExistingSocket: boolean;
         readonly credentialAcquired: (revision: number) => void;
     }): Promise<WebSocket>;
     private connectWebSocket;

package/dist/model/openai-responses.js

@@ -13,13 +13,33 @@ const X_CODEX_TURN_STATE = 'x-codex-turn-state';
 const RESPONSES_LITE_HEADER = 'x-openai-internal-codex-responses-lite';
 const RESPONSES_LITE_METADATA = 'ws_request_header_x_openai_internal_codex_responses_lite';
 export class OpenAiResponsesAdapter {
-    configuration;
     prefixIdentity = randomUUID();
     #cachedState = {};
     #cacheLeased = false;
     #closed = false;
+    #configuration;
     constructor(configuration) {
-        this.configuration = configuration;
+        this.#configuration = configuration;
+    }
+    get configuration() {
+        return this.#configuration;
+    }
+    prepareReconfigure(configuration) {
+        if (!sameResponsesAdapterConfiguration(this.#configuration, configuration))
+            return undefined;
+        return () => {
+            this.#configuration = configuration;
+        };
+    }
+    restoreContinuation(checkpoint) {
+        if (this.#cacheLeased ||
+            this.#cachedState.lastRequest !== undefined ||
+            this.#cachedState.lastResponse !== undefined ||
+            checkpoint.protocol !== 'OPENAI_RESPONSES' ||
+            checkpoint.configurationHash !== responsesConfigurationHash(this.#configuration))
+            return false;
+        this.#cachedState.restoredContinuation = checkpoint;
+        return true;
     }
     async *start(request, signal) {
         const turn = new OpenAiResponsesTurnSession(this, {}, false, true);
@@ -53,14 +73,13 @@ export class OpenAiResponsesAdapter {
             return;
         }
         if (state.socket !== undefined && state.socket.readyState !== WebSocket.OPEN)
-            invalidateResponsesWebSocket(state, true);
+            invalidateResponsesWebSocket(state, false);
         this.#cachedState = state;
         this.#cacheLeased = false;
     }
     async *startTurn(request, signal, turn, prepared) {
         let useContinuation = prepared.continuation;
         let requestBody = prepared.body;
-        let requiresExistingSocket = prepared.requiresExistingSocket;
         let credentialReason = 'REQUEST';
         let unauthorizedRetryUsed = false;
         let invalidContinuationFallbackUsed = false;
@@ -87,7 +106,7 @@ export class OpenAiResponsesAdapter {
                 credentialReason: attemptCredentialReason
             });
             try {
-                for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, requiresExistingSocket, turn)) {
+                for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -143,7 +162,6 @@ export class OpenAiResponsesAdapter {
                     invalidContinuationFallbackUsed = true;
                     useContinuation = false;
                     requestBody = prepared.fullBody;
-                    requiresExistingSocket = false;
                     turn.invalidateWebSocket();
                     credentialReason = 'RECONNECT';
                     await reportFailure(true, {
@@ -192,14 +210,13 @@ export class OpenAiResponsesAdapter {
                         : 'REQUEST';
                 useContinuation = false;
                 requestBody = prepared.fullBody;
-                requiresExistingSocket = false;
                 if (error instanceof MarAgentError && error.details?.transport === 'WEBSOCKET')
                     turn.invalidateWebSocket();
                 await waitForModelRetry(retryAfter(error), attempt, signal, delayMs);
             }
         }
     }
-    async *startAttempt(request, signal, body, continuation, credentialReason, requiresExistingSocket, turn) {
+    async *startAttempt(request, signal, body, continuation, credentialReason, turn) {
         let latestCredentialRevision;
         const fetchResponse = async (requestBody) => {
             const serializedBody = JSON.stringify(requestBody);
@@ -233,7 +250,6 @@ export class OpenAiResponsesAdapter {
                     reason: credentialReason,
                     signal,
                     continuation,
-                    requiresExistingSocket,
                     turn,
                     credentialAcquired: (revision) => (latestCredentialRevision = revision)
                 });
@@ -517,6 +533,15 @@ export class OpenAiResponsesAdapter {
             });
     }
 }
+function sameResponsesAdapterConfiguration(current, next) {
+    const { apiKey: currentApiKey, credentialProvider: currentCredentialProvider, imageGeneration: _currentImageGeneration, ...currentTransport } = current;
+    const { apiKey: nextApiKey, credentialProvider: nextCredentialProvider, imageGeneration: _nextImageGeneration, ...nextTransport } = next;
+    const credentialsAreRebindable = (currentCredentialProvider !== undefined && nextCredentialProvider !== undefined) ||
+        (currentApiKey !== undefined &&
+            nextApiKey !== undefined &&
+            currentApiKey.reveal() === nextApiKey.reveal());
+    return credentialsAreRebindable && isDeepStrictEqual(currentTransport, nextTransport);
+}
 class OpenAiResponsesTurnSession {
     adapter;
     state;
@@ -561,7 +586,7 @@ class OpenAiResponsesTurnSession {
                 for await (const event of this.adapter.startTurn({
                     ...request,
                     onAttemptDiagnostic: async (diagnostic) => request.onAttemptDiagnostic?.({ ...diagnostic, prewarm: true })
-                }, signal, this, { fullBody: warmBody, body: warmBody, continuation: false, requiresExistingSocket: false })) {
+                }, signal, this, { fullBody: warmBody, body: warmBody, continuation: false })) {
                     if (event.type === 'response.started' && event.responseId !== 'unknown')
                         warmId = event.responseId;
                     if (event.type === 'completed')
@@ -607,6 +632,7 @@ class OpenAiResponsesTurnSession {
                 (outputItems.length > 0 || !sawUnrepresentedOutput)) {
                 this.state.lastRequest = prepared.fullBody;
                 this.state.lastResponse = { responseId, outputItems };
+                delete this.state.restoredContinuation;
             }
             else
                 clearResponsesContinuation(this.state);
@@ -629,17 +655,31 @@ class OpenAiResponsesTurnSession {
     resetContinuation() {
         clearResponsesContinuation(this.state);
     }
+    continuationCheckpoint() {
+        const request = this.state.lastRequest;
+        const response = this.state.lastResponse;
+        if (request === undefined || response === undefined)
+            return this.state.restoredContinuation;
+        const baseline = [...request.input, ...response.outputItems];
+        return {
+            version: 1,
+            protocol: 'OPENAI_RESPONSES',
+            configurationHash: responsesConfigurationHash(this.adapter.configuration),
+            responseId: response.responseId,
+            requestPropertiesHash: responsesRequestPropertiesHash(request),
+            inputPrefixLength: baseline.length,
+            inputPrefixHash: hashResponsesValue(baseline)
+        };
+    }
     prepareRequest(request) {
         if (this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
             this.state.socket !== undefined &&
             this.state.socket.readyState !== WebSocket.OPEN)
-            invalidateResponsesWebSocket(this.state, true);
+            invalidateResponsesWebSocket(this.state, false);
         const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages, this.adapter.prefixIdentity);
         if (this.adapter.configuration.responsesPreviousResponseId) {
             const incremental = incrementalResponsesInput(this.state, fullBody);
-            if (incremental !== undefined &&
-                (this.adapter.configuration.responsesTransport?.transport !== 'WEBSOCKET' ||
-                    this.state.socket?.readyState === WebSocket.OPEN)) {
+            if (incremental !== undefined) {
                 const responseId = this.state.lastResponse.responseId;
                 delete this.state.lastResponse;
                 return {
@@ -649,8 +689,7 @@ class OpenAiResponsesTurnSession {
                         input: incremental,
                         previous_response_id: responseId
                     },
-                    continuation: true,
-                    requiresExistingSocket: this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET'
+                    continuation: true
                 };
             }
             if (this.allowExternalContinuation &&
@@ -664,16 +703,14 @@ class OpenAiResponsesTurnSession {
                         input: deltaBody.input,
                         previous_response_id: request.continuation.previousResponseId
                     },
-                    continuation: true,
-                    requiresExistingSocket: false
+                    continuation: true
                 };
             }
         }
         return {
             fullBody,
             body: fullBody,
-            continuation: false,
-            requiresExistingSocket: false
+            continuation: false
         };
     }
     fullRequestBody() {
@@ -714,14 +751,9 @@ class OpenAiResponsesTurnSession {
     async webSocketForRequest(input) {
         const endpoint = webSocketEndpoint(input.configuration.baseUrl);
         const existingSocket = this.state.socket;
-        if (input.requiresExistingSocket &&
-            (existingSocket?.readyState !== WebSocket.OPEN || this.state.endpoint !== endpoint)) {
-            invalidateResponsesWebSocket(this.state, true);
-            throw unavailableContinuationConnection();
-        }
         if (existingSocket !== undefined &&
             (existingSocket.readyState !== WebSocket.OPEN || this.state.endpoint !== endpoint))
-            invalidateResponsesWebSocket(this.state, true);
+            invalidateResponsesWebSocket(this.state, false);
         if (this.state.socket === undefined) {
             const handshakeCredential = await acquireResponsesCredential(input.configuration, input.reason);
             input.credentialAcquired(handshakeCredential.revision);
@@ -729,10 +761,9 @@ class OpenAiResponsesTurnSession {
         }
         const requestCredential = await acquireResponsesCredential(input.configuration, input.reason);
         input.credentialAcquired(requestCredential.revision);
-        if (requestCredential.revision !== this.state.credentialRevision) {
-            invalidateResponsesWebSocket(this.state, true);
-            if (input.continuation)
-                throw unavailableContinuationConnection();
+        if (requestCredential.revision !== this.state.credentialRevision ||
+            responsesCredentialFingerprint(requestCredential) !== this.state.credentialFingerprint) {
+            invalidateResponsesWebSocket(this.state, false);
             await this.connectWebSocket(endpoint, requestCredential, input.promptCacheKey, input.signal);
         }
         if (input.signal.aborted) {
@@ -787,6 +818,7 @@ class OpenAiResponsesTurnSession {
         this.state.socket = socket;
         this.state.endpoint = endpoint;
         this.state.credentialRevision = credential.revision;
+        this.state.credentialFingerprint = responsesCredentialFingerprint(credential);
         this.state.connectionId = connectionId;
         this.state.proxyType = proxyType;
     }
@@ -864,9 +896,18 @@ function uuidV5(namespace, value) {
 function incrementalResponsesInput(state, current) {
     const previous = state.lastRequest;
     const completion = state.lastResponse;
-    if (previous === undefined ||
-        completion === undefined ||
-        !responsesRequestPropertiesMatch(previous, current))
+    if (previous === undefined || completion === undefined) {
+        const restored = state.restoredContinuation;
+        if (restored === undefined ||
+            restored.requestPropertiesHash !== responsesRequestPropertiesHash(current) ||
+            current.input.length < restored.inputPrefixLength ||
+            restored.inputPrefixHash !==
+                hashResponsesValue(current.input.slice(0, restored.inputPrefixLength)))
+            return undefined;
+        state.lastResponse = { responseId: restored.responseId, outputItems: [] };
+        return current.input.slice(restored.inputPrefixLength);
+    }
+    if (!responsesRequestPropertiesMatch(previous, current))
         return undefined;
     const baseline = [...previous.input, ...completion.outputItems];
     if (current.input.length < baseline.length)
@@ -877,31 +918,53 @@ function incrementalResponsesInput(state, current) {
     return current.input.slice(baseline.length);
 }
 function responsesRequestPropertiesMatch(previous, current) {
-    const keys = [
-        'model',
-        'instructions',
-        'tools',
-        'tool_choice',
-        'parallel_tool_calls',
-        'reasoning',
-        'store',
-        'stream',
-        'include',
-        'prompt_cache_key',
-        'text',
-        'client_metadata'
-    ];
-    return keys.every((key) => isDeepStrictEqual(previous[key], current[key]));
+    return RESPONSES_REQUEST_PROPERTY_KEYS.every((key) => isDeepStrictEqual(previous[key], current[key]));
 }
 function clearResponsesContinuation(state) {
     delete state.lastRequest;
     delete state.lastResponse;
+    delete state.restoredContinuation;
+}
+const RESPONSES_REQUEST_PROPERTY_KEYS = [
+    'model',
+    'instructions',
+    'tools',
+    'tool_choice',
+    'parallel_tool_calls',
+    'reasoning',
+    'store',
+    'stream',
+    'include',
+    'prompt_cache_key',
+    'text',
+    'client_metadata'
+];
+function responsesRequestPropertiesHash(request) {
+    return hashResponsesValue(Object.fromEntries(RESPONSES_REQUEST_PROPERTY_KEYS.map((key) => [key, request[key]])));
+}
+function hashResponsesValue(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function responsesConfigurationHash(configuration) {
+    const { apiKey: _apiKey, credentialProvider: _credentialProvider, imageGeneration: _imageGeneration, ...identity } = configuration;
+    return hashResponsesValue(identity);
+}
+function responsesCredentialFingerprint(credential) {
+    return hashResponsesValue({
+        bearer: credential.bearer.reveal(),
+        headers: Object.fromEntries(Object.entries(credential.headers).map(([name, value]) => [
+            name,
+            typeof value === 'string' ? value : value.reveal()
+        ])),
+        socks5Url: credential.socks5Url?.reveal()
+    });
 }
 function invalidateResponsesWebSocket(state, clearContinuation) {
     const socket = state.socket;
     delete state.socket;
     delete state.endpoint;
     delete state.credentialRevision;
+    delete state.credentialFingerprint;
     delete state.connectionId;
     delete state.proxyType;
     if (clearContinuation)
@@ -911,16 +974,6 @@ function invalidateResponsesWebSocket(state, clearContinuation) {
         socket.readyState !== WebSocket.CLOSING)
         terminateWebSocket(socket);
 }
-function unavailableContinuationConnection() {
-    return new MarAgentError('previous_response_not_found', 'The previous response is unavailable on the current WebSocket connection.', {
-        details: {
-            reason: 'OPENAI_RESPONSES_CONTINUATION_CONNECTION_UNAVAILABLE',
-            transport: 'WEBSOCKET',
-            continuation: true
-        },
-        retryable: true
-    });
-}
 function turnStateFromEvent(event) {
     for (const headers of [
         record(event.headers),
@@ -958,7 +1011,6 @@ async function* webSocketResponseEvents(input) {
         reason: input.reason,
         signal: input.signal,
         continuation: input.continuation,
-        requiresExistingSocket: input.requiresExistingSocket,
         credentialAcquired: input.credentialAcquired
     });
     const body = input.turn.withTurnStateMetadata(input.body);

package/dist/runtime/compact.js

@@ -95,7 +95,9 @@ export function buildNativeCompactionMessages(messages, input = {}) {
     const focus = input.focus?.trim();
     const contract = input.highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt();
     return [
-        ...messages.map((message) => {
+        ...messages
+            .filter((message) => message.contextKind !== 'private')
+            .map((message) => {
             if (!message.images?.length)
                 return message;
             const textOnly = { ...message };

package/dist/runtime/context-projection.js

@@ -139,6 +139,7 @@ export function restoreModelContext(payload, providerModelId) {
                 role: 'provider',
                 provider: 'ANTHROPIC_MESSAGES',
                 providerModelId: modelId,
+                contextKind: 'private',
                 content: '',
                 item
             }

package/dist/sdk/agent.js

@@ -55,6 +55,7 @@ export async function createMarAgent(options) {
         throw new MarAgentError('MAR_AGENT_HOST_INCOMPATIBLE', 'Host mode does not match Agent mode.');
     const store = await JsonlSessionStore.open(description.homeDirectory);
     const active = new Map();
+    const activeExecutionAdapters = new Set();
     const executionResults = new Map();
     const sessionRuntimes = new Map();
     let disposed = false;
@@ -354,6 +355,7 @@ export async function createMarAgent(options) {
                             const titleModel = [...executionModels.values()].find((model) => model.titleGeneration) ??
                                 executionModels.get(input.modelId ?? executionDefaultModelId);
                             titleAdapter = createAdapter(titleModel.id, executionModels);
+                            activeExecutionAdapters.add(titleAdapter);
                             titleTask = generateSessionTitle(titleAdapter, input.prompt, titleModel.defaultReasoningEffort, controller.signal, recordModelAttempt('TITLE')).catch(() => undefined);
                         }
                     }
@@ -370,12 +372,17 @@ export async function createMarAgent(options) {
                             turnId
                         });
                     selectedAdapter = sessionAdapter(input.modelId ?? executionDefaultModelId, executionModels);
+                    const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
+                    const restoredContinuation = latestModelContinuationCheckpoint(contextRecords, selectedModel.id);
+                    if (restoredContinuation !== undefined)
+                        selectedAdapter.restoreContinuation?.(restoredContinuation);
                     if (options.adapterFactory !== undefined &&
-                        selectedAdapter.createTurnSession === undefined)
+                        selectedAdapter.createTurnSession === undefined) {
                         executionScopedAdapters.add(selectedAdapter);
+                        activeExecutionAdapters.add(selectedAdapter);
+                    }
                     const selected = createModelTurnSession(selectedAdapter);
                     selectedTurn = selected;
-                    const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                     const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
@@ -819,6 +826,9 @@ export async function createMarAgent(options) {
                                         content: '',
                                         provider: event.provider,
                                         providerModelId: selectedModel.id,
+                                        ...(event.provider === 'ANTHROPIC_MESSAGES'
+                                            ? { contextKind: 'private' }
+                                            : {}),
                                         item: event.item
                                     };
                                     messages.push(message);
@@ -991,6 +1001,17 @@ export async function createMarAgent(options) {
                             };
                         else if (selectedModel.responsesPreviousResponseId)
                             sessionRuntime.responsesChain = undefined;
+                        const continuationCheckpoint = selected.continuationCheckpoint?.();
+                        if (mode !== 'compact' && continuationCheckpoint !== undefined)
+                            await store.append(sessionId, {
+                                type: 'responses.continuation',
+                                payload: {
+                                    modelId: selectedModel.id,
+                                    checkpoint: continuationCheckpoint
+                                },
+                                executionId,
+                                turnId
+                            });
                         if (pendingTools.length === 0 && mailbox.length > 0) {
                             await appendMailboxMessages();
                             finalAnswer = '';
@@ -1270,7 +1291,16 @@ export async function createMarAgent(options) {
                     await selectedTurn?.close().catch(() => undefined);
                     if (titleAdapter !== undefined && titleAdapter !== selectedAdapter)
                         executionScopedAdapters.add(titleAdapter);
-                    await closeModelAdapters(executionScopedAdapters).catch(() => undefined);
+                    try {
+                        await closeModelAdapters(executionScopedAdapters);
+                    }
+                    catch {
+                        // Execution cleanup is best effort.
+                    }
+                    finally {
+                        for (const adapter of executionScopedAdapters)
+                            activeExecutionAdapters.delete(adapter);
+                    }
                     subagents?.endParentExecution(executionId);
                     await releaseSession?.();
                     active.delete(`${sessionId}:${executionId}`);
@@ -1346,30 +1376,60 @@ export async function createMarAgent(options) {
             const activeSessions = activeSessionIds();
             if ([...activeSessions].some((sessionId) => sessionRuntimes.get(sessionId)?.sourceType !== 'subagent'))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Models cannot be reconfigured while a main execution is active.');
-            const activeAdapters = new Set();
+            const activeAdapters = new Set(activeExecutionAdapters);
             for (const [sessionId, runtime] of sessionRuntimes)
                 if (activeSessions.has(sessionId))
                     for (const adapter of runtime.adapters.values())
                         activeAdapters.add(adapter);
             const inactiveRuntimes = [...sessionRuntimes].flatMap(([sessionId, runtime]) => activeSessions.has(sessionId) ? [] : [runtime]);
-            const adapters = inactiveRuntimes
-                .flatMap((runtime) => [...runtime.adapters.values()])
-                .filter((adapter) => !activeAdapters.has(adapter));
             reconfiguring = true;
             try {
+                const reconfigurationCommits = new Map();
+                for (const runtime of inactiveRuntimes)
+                    for (const [modelId, adapter] of runtime.adapters) {
+                        if (activeAdapters.has(adapter))
+                            continue;
+                        const configuration = next.models.get(modelId);
+                        const commit = configuration === undefined ? undefined : adapter.prepareReconfigure?.(configuration);
+                        if (commit !== undefined)
+                            reconfigurationCommits.set(adapter, commit);
+                    }
+                const retainedAdapters = new Set(reconfigurationCommits.keys());
+                const adapters = [
+                    ...new Set(inactiveRuntimes.flatMap((runtime) => [...runtime.adapters.values()]))
+                ].filter((adapter) => !activeAdapters.has(adapter) && !retainedAdapters.has(adapter));
+                for (const runtime of inactiveRuntimes) {
+                    for (const [modelId, adapter] of runtime.adapters)
+                        if (!retainedAdapters.has(adapter))
+                            runtime.adapters.delete(modelId);
+                    if (runtime.responsesChain !== undefined &&
+                        !retainedAdapters.has(runtime.adapters.get(runtime.responsesChain.modelId)))
+                        runtime.responsesChain = undefined;
+                }
                 await closeModelAdapters(adapters);
                 if (disposed)
                     throw new MarAgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.');
+                for (const commit of reconfigurationCommits.values())
+                    commit();
                 models = next.models;
                 defaultModelId = next.defaultModelId;
                 modelGeneration++;
                 for (const provider of next.credentialProviders)
                     credentialProviders.add(provider);
                 for (const runtime of inactiveRuntimes) {
-                    runtime.responsesChain = undefined;
-                    runtime.adapters.clear();
                     runtime.adapterGeneration = modelGeneration;
                 }
+                const liveProviders = new Set(next.credentialProviders);
+                for (const adapter of activeExecutionAdapters)
+                    addModelCredentialProviders(liveProviders, adapter.configuration);
+                for (const runtime of sessionRuntimes.values())
+                    for (const adapter of runtime.adapters.values())
+                        addModelCredentialProviders(liveProviders, adapter.configuration);
+                const obsoleteProviders = [...credentialProviders].filter((provider) => !liveProviders.has(provider));
+                const providerCloseResults = await Promise.allSettled(obsoleteProviders.map((provider) => provider.close()));
+                for (const [index, result] of providerCloseResults.entries())
+                    if (result.status === 'fulfilled')
+                        credentialProviders.delete(obsoleteProviders[index]);
             }
             finally {
                 reconfiguring = false;
@@ -1512,9 +1572,46 @@ function createModelTurnSession(adapter) {
             }
         },
         resetContinuation: () => turn.resetContinuation?.(),
+        continuationCheckpoint: () => turn.continuationCheckpoint?.(),
         close: () => turn.close()
     };
 }
+function latestModelContinuationCheckpoint(records, modelId) {
+    let checkpoint;
+    for (const record of records) {
+        if (record.type === 'compact.completed' || record.type === 'context.gc.completed') {
+            checkpoint = undefined;
+            continue;
+        }
+        if (record.type !== 'responses.continuation')
+            continue;
+        const payload = record.payload;
+        if (payload === null || typeof payload !== 'object' || Array.isArray(payload))
+            continue;
+        const candidateModelId = payload.modelId;
+        const candidate = payload.checkpoint;
+        if (candidateModelId !== modelId || !isModelContinuationCheckpoint(candidate))
+            continue;
+        checkpoint = candidate;
+    }
+    return checkpoint;
+}
+function isModelContinuationCheckpoint(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const checkpoint = value;
+    return (checkpoint.version === 1 &&
+        checkpoint.protocol === 'OPENAI_RESPONSES' &&
+        isBoundedString(checkpoint.configurationHash, 64) &&
+        isBoundedString(checkpoint.responseId, 1_024) &&
+        isBoundedString(checkpoint.requestPropertiesHash, 64) &&
+        Number.isSafeInteger(checkpoint.inputPrefixLength) &&
+        checkpoint.inputPrefixLength >= 0 &&
+        isBoundedString(checkpoint.inputPrefixHash, 64));
+}
+function isBoundedString(value, maximumLength) {
+    return typeof value === 'string' && value.length > 0 && value.length <= maximumLength;
+}
 function modelAttemptFailureDiagnostic(diagnostic, summary) {
     if (summary === undefined)
         return diagnostic;
@@ -1526,7 +1623,16 @@ function modelAttemptFailureDiagnostic(diagnostic, summary) {
     };
 }
 async function closeModelAdapters(adapters) {
-    await Promise.all([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
+    const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure !== undefined)
+        throw failure.reason;
+}
+function addModelCredentialProviders(target, configuration) {
+    if (configuration.credentialProvider !== undefined)
+        target.add(configuration.credentialProvider);
+    if (configuration.imageGeneration !== undefined)
+        target.add(configuration.imageGeneration.credentialProvider);
 }
 function truncateUtf8(value, maximumBytes) {
     const bytes = Buffer.from(value);

package/dist/session/jsonl-store.js

@@ -302,7 +302,7 @@ export class JsonlSessionStore {
                 });
                 const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
                 for (const record of retained) {
-                    if (record.type === 'context.gc.completed')
+                    if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
                         continue;
                     await this.append(target.id, {
                         type: record.type,
@@ -368,7 +368,9 @@ export class JsonlSessionStore {
                 : records.findLastIndex((record) => record.turnId === input.boundaryTurnId);
             if (input.boundaryTurnId !== null && boundaryIndex < 0)
                 throw new MarAgentError('MAR_AGENT_ROLLBACK_TARGET_INVALID', 'Session rollback target was not found.');
-            const retained = records.slice(0, boundaryIndex + 1);
+            const retained = records
+                .slice(0, boundaryIndex + 1)
+                .filter((record) => record.type !== 'responses.continuation');
             const staged = await stageRollbackSegments(this.sessionDirectory(sessionId), retained);
             const transactionId = randomUUID();
             let generatedTrash = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.83",
+  "version": "0.9.84",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",