@myagentroam/agent 0.9.144 → 0.9.146

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

@@ -32,7 +32,6 @@ export declare function serializeModel(model: CliModelConfiguration): {
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
-    responsesEncoding?: "STANDARD" | "LITE" | undefined;
     responsesToolNamespace?: string | undefined;
     enabled: boolean;
 } | {
@@ -60,7 +59,6 @@ export declare function serializeModel(model: CliModelConfiguration): {
     fastMode?: boolean | undefined;
     serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
-    responsesEncoding?: "STANDARD" | "LITE" | undefined;
     responsesToolNamespace?: string | undefined;
     enabled: boolean;
 };

package/dist/agent-core/model/catalog-file.js

@@ -52,6 +52,14 @@ function parseCliModelCatalog(input, options = {}) {
         return parseModelCatalog(input, options);
     const externalCredentialModels = new Set();
     const normalizedModels = input.models.map((model, index) => {
+        if (isRecord(model) && Object.hasOwn(model, 'responsesEncoding')) {
+            if (model.protocol !== 'OPENAI_RESPONSES' ||
+                (model.responsesEncoding !== 'STANDARD' && model.responsesEncoding !== 'LITE'))
+                throw invalidCatalog();
+            const { responsesEncoding: _encoding, ...configuration } = model;
+            void _encoding;
+            model = configuration;
+        }
         if (!isRecord(model) || !Object.hasOwn(model, 'credential'))
             return model;
         const credential = model.credential;

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

@@ -89,10 +89,6 @@ declare const rawModelSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         transport: z.ZodLiteral<"WEBSOCKET">;
     }, z.core.$strict>], "transport">>;
-    responsesEncoding: z.ZodOptional<z.ZodEnum<{
-        STANDARD: "STANDARD";
-        LITE: "LITE";
-    }>>;
     responsesToolNamespace: z.ZodOptional<z.ZodString>;
     responsesPreviousResponseId: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     enabled: z.ZodBoolean;
@@ -108,7 +104,7 @@ export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModel
     responsesPreviousResponseId?: boolean;
 }
 export declare function supportsResponsesConfigurationUpdates(model: Pick<MarAgentModelConfiguration, 'responsesConfigurationUpdates' | 'codexCredential'>): boolean;
-export declare function usesResponsesConfigurationUpdates(model: Pick<MarAgentModelConfiguration, 'protocol' | 'responsesEncoding' | 'responsesConfigurationUpdates' | 'codexCredential'>): boolean;
+export declare function usesResponsesConfigurationUpdates(model: Pick<MarAgentModelConfiguration, 'protocol' | 'responsesConfigurationUpdates' | 'codexCredential'>): boolean;
 export interface ModelCatalog {
     version: 1;
     defaultModelId?: string;

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

@@ -54,7 +54,6 @@ const rawModelSchema = z
     serviceTier: z.enum(['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast']).optional(),
     hostedWebSearch: z.boolean(),
     responsesTransport: rawResponsesTransportSchema.optional(),
-    responsesEncoding: z.enum(['STANDARD', 'LITE']).optional(),
     responsesToolNamespace: z
         .string()
         .regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u)
@@ -93,10 +92,7 @@ const rawModelSchema = z
         });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesTransport !== undefined)
         context.addIssue({ code: 'custom', message: 'Responses transport requires Responses.' });
-    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesEncoding !== undefined)
-        context.addIssue({ code: 'custom', message: 'Responses encoding requires Responses.' });
-    if (value.responsesToolNamespace !== undefined &&
-        (value.protocol !== 'OPENAI_RESPONSES' || value.responsesEncoding === 'LITE'))
+    if (value.responsesToolNamespace !== undefined && value.protocol !== 'OPENAI_RESPONSES')
         context.addIssue({
             code: 'custom',
             path: ['responsesToolNamespace'],
@@ -111,9 +107,7 @@ export function supportsResponsesConfigurationUpdates(model) {
     return model.responsesConfigurationUpdates ?? model.codexCredential === true;
 }
 export function usesResponsesConfigurationUpdates(model) {
-    return (model.protocol === 'OPENAI_RESPONSES' &&
-        model.responsesEncoding !== 'LITE' &&
-        supportsResponsesConfigurationUpdates(model));
+    return model.protocol === 'OPENAI_RESPONSES' && supportsResponsesConfigurationUpdates(model);
 }
 export function resolveModelDefaultReasoningEffort(model) {
     const configured = marAgentReasoningEffortSchema.safeParse(model.defaultReasoningEffort);

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

@@ -30,7 +30,6 @@ export interface ModelAttemptDiagnostic {
     attempt: number;
     maxAttempts: number;
     continuation: boolean;
-    prewarm?: boolean;
     credentialReason: ModelCredentialAcquireReason;
     semanticEventObserved?: boolean;
     firstSemanticEventType?: ModelEvent['type'];

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

@@ -27,7 +27,6 @@ interface PreparedResponsesRequest {
 }
 export declare class OpenAiResponsesAdapter implements ModelAdapter {
     #private;
-    readonly prefixIdentity: `${string}-${string}-${string}-${string}-${string}`;
     constructor(configuration: MarAgentModelConfiguration);
     get configuration(): MarAgentModelConfiguration;
     prepareReconfigure(configuration: MarAgentModelConfiguration): (() => void) | undefined;
@@ -67,5 +66,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, nativeToolSearch?: boolean, configurationUpdates?: boolean): Record<string, unknown>[];
+export declare function openAiInput(messages: ModelRequest['messages'], images: ModelRequest['images'] | undefined, modelId: string, requireEncryptedReasoning: boolean, configurationUpdates?: boolean): Record<string, unknown>[];
 export {};

package/dist/agent-core/model/openai-responses.js

@@ -11,10 +11,7 @@ const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
 export const OPENAI_RESPONSES_EARLY_EOF_REASON = 'OPENAI_RESPONSES_EARLY_EOF';
 export const OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON = 'OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT';
 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 {
-    prefixIdentity = randomUUID();
     #cachedState = {};
     #cacheLeased = false;
     #closed = false;
@@ -242,12 +239,12 @@ export class OpenAiResponsesAdapter {
         const fetchResponse = async (requestBody) => {
             const serializedBody = JSON.stringify(requestBody);
             return await fetchModelResponse(responsesEndpoint(this.configuration.baseUrl), async () => {
-                const credential = await acquireResponsesCredential(this.configuration, credentialReason);
+                const credential = await acquireResponsesCredential(this.configuration, credentialReason, signal);
                 latestCredentialRevision = credential.revision;
                 return {
                     request: {
                         method: 'POST',
-                        headers: responsesHeaders(credential, request.promptCacheKey, turn.currentTurnState(), this.configuration.responsesEncoding === 'LITE'),
+                        headers: responsesHeaders(credential, request.promptCacheKey, turn.currentTurnState()),
                         body: serializedBody,
                         redirect: 'manual'
                     },
@@ -629,49 +626,8 @@ class OpenAiResponsesTurnSession {
         let completed = false;
         let sawUnrepresentedOutput = false;
         try {
-            let prepared = this.prepareRequest(request);
+            const prepared = this.prepareRequest(request);
             this.#fullBody = prepared.fullBody;
-            if (this.adapter.configuration.responsesEncoding === 'LITE' &&
-                this.adapter.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
-                responsesContinuationEnabled(this.adapter.configuration) &&
-                this.state.lastRequest === undefined &&
-                request.allowTools !== false &&
-                request.toolChoice !== 'none' &&
-                (request.tools.length > 0 || this.adapter.configuration.hostedWebSearch)) {
-                const prefix = prepared.fullBody.input.slice(0, request.system ? 2 : 1);
-                const warmBody = { ...prepared.fullBody, input: prefix, generate: false };
-                this.#fullBody = warmBody;
-                let warmId;
-                let warmCompleted = false;
-                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 })) {
-                    if (event.type === 'response.started' && event.responseId !== 'unknown')
-                        warmId = event.responseId;
-                    if (event.type === 'completed')
-                        warmCompleted = event.reason === 'completed';
-                    if (event.type === 'client_tool.call' ||
-                        event.type === 'output.delta' ||
-                        event.type === 'text.delta' ||
-                        event.type === 'text.completed' ||
-                        event.type === 'response.item' ||
-                        event.type === 'reasoning.summary') {
-                        this.invalidateWebSocket();
-                        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Responses prewarm returned model output.');
-                    }
-                }
-                warmId = this.#completedResponseId ?? warmId;
-                this.#completedResponseId = undefined;
-                if (!warmCompleted || !warmId) {
-                    this.invalidateWebSocket();
-                    throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Responses prewarm did not complete.');
-                }
-                this.state.lastRequest = { ...prepared.fullBody, input: prefix };
-                this.state.lastResponse = { responseId: warmId, outputItems: [] };
-                prepared = this.prepareRequest(request);
-                this.#fullBody = prepared.fullBody;
-            }
             this.#completedResponseId = undefined;
             for await (const event of this.adapter.startTurn(request, signal, this, prepared)) {
                 if (event.type === 'response.started' && event.responseId !== 'unknown')
@@ -732,7 +688,7 @@ class OpenAiResponsesTurnSession {
             invalidateResponsesWebSocket(this.state, false);
             clearResponsesContinuation(this.state);
         }
-        const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages, this.adapter.prefixIdentity);
+        const fullBody = responsesRequestBody(this.adapter.configuration, request, request.messages);
         if (responsesContinuationEnabled(this.adapter.configuration)) {
             const incremental = incrementalResponsesInput(this.state, fullBody);
             if (incremental !== undefined) {
@@ -806,11 +762,11 @@ class OpenAiResponsesTurnSession {
             throw localContinuationReset();
         }
         if (this.state.socket === undefined) {
-            const handshakeCredential = await acquireResponsesCredential(input.configuration, input.reason);
+            const handshakeCredential = await acquireResponsesCredential(input.configuration, input.reason, input.signal);
             input.credentialAcquired(handshakeCredential.revision);
             await this.connectWebSocket(endpoint, handshakeCredential, input.promptCacheKey, input.signal);
         }
-        const requestCredential = await acquireResponsesCredential(input.configuration, input.reason);
+        const requestCredential = await acquireResponsesCredential(input.configuration, input.reason, input.signal);
         input.credentialAcquired(requestCredential.revision);
         if (requestCredential.revision !== this.state.credentialRevision ||
             responsesCredentialFingerprint(requestCredential) !== this.state.credentialFingerprint) {
@@ -853,7 +809,7 @@ class OpenAiResponsesTurnSession {
         const proxyType = credential.socks5Url === undefined ? 'DIRECT' : 'SOCKS5';
         this.#connectionDiagnostic = { connectionId, connectionReused: false, proxyType };
         const socket = new WebSocket(parsedEndpoint, {
-            headers: Object.fromEntries(webSocketHeaders(credential, promptCacheKey, this.adapter.configuration.responsesEncoding === 'LITE')),
+            headers: Object.fromEntries(webSocketHeaders(credential, promptCacheKey)),
             perMessageDeflate: false,
             maxPayload: 16 * 1024 * 1024,
             handshakeTimeout: 30_000,
@@ -884,10 +840,10 @@ function localContinuationReset() {
 function isLocalContinuationReset(error) {
     return error instanceof MarAgentError && error.code === 'MAR_AGENT_RESPONSES_CONTINUATION_RESET';
 }
-function responsesRequestBody(configuration, request, messages, prefixIdentity = '') {
+function responsesRequestBody(configuration, request, messages) {
     const tools = request.allowTools === false
         ? []
-        : request.tools.map((tool) => configuration.responsesEncoding !== 'LITE' && tool.nativeType === 'tool_search'
+        : request.tools.map((tool) => tool.nativeType === 'tool_search'
             ? {
                 type: 'tool_search',
                 execution: 'client',
@@ -910,27 +866,7 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
     if (request.allowTools !== false && configuration.hostedWebSearch)
         tools.push({ type: 'web_search' });
     const toolChoice = request.toolChoice ?? 'auto';
-    const lite = configuration.responsesEncoding === 'LITE';
-    const input = openAiInput(messages, request.images, configuration.id, true, !lite, usesResponsesConfigurationUpdates(configuration));
-    if (lite) {
-        const namespace = uuidV5('6ba7b812-9dad-11d1-80b4-00c04fd430c8', request.promptCacheKey ?? prefixIdentity);
-        const prefix = [
-            {
-                type: 'additional_tools',
-                role: 'developer',
-                id: `at_${uuidV5(namespace, JSON.stringify(tools))}`,
-                tools
-            }
-        ];
-        if (request.system)
-            prefix.push({
-                type: 'message',
-                role: 'developer',
-                id: `msg_${uuidV5(namespace, request.system)}`,
-                content: [{ type: 'input_text', text: request.system }]
-            });
-        input.unshift(...prefix);
-    }
+    const input = openAiInput(messages, request.images, configuration.id, true, usesResponsesConfigurationUpdates(configuration));
     return {
         model: configuration.modelId,
         ...(configuration.serviceTier !== undefined
@@ -938,15 +874,12 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
             : configuration.fastMode === true
                 ? { service_tier: 'priority' }
                 : {}),
-        ...(lite
-            ? {
-                tool_choice: toolChoice,
-                client_metadata: { [RESPONSES_LITE_METADATA]: 'true' }
-            }
-            : { instructions: request.system, tools, tool_choice: toolChoice }),
+        instructions: request.system,
+        tools,
+        tool_choice: toolChoice,
         input,
         stream: true,
-        parallel_tool_calls: !lite,
+        parallel_tool_calls: true,
         store: false,
         text: { verbosity: 'low' },
         include: [
@@ -960,23 +893,10 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
             effort: request.requestReasoningEffort?.trim() ||
                 request.reasoningEffort?.trim() ||
                 resolveModelDefaultReasoningEffort(configuration),
-            summary: 'auto',
-            ...(lite ? { context: 'all_turns' } : {})
+            summary: 'auto'
         }
     };
 }
-function uuidV5(namespace, value) {
-    // UUID v5 matches the reference item-identity algorithm; this is not a secret hash.
-    const bytes = createHash('sha1')
-        .update(Buffer.from(namespace.replaceAll('-', ''), 'hex'))
-        .update(value)
-        .digest()
-        .subarray(0, 16);
-    bytes[6] = (bytes[6] & 0x0f) | 0x50;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const hex = bytes.toString('hex');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
 function incrementalResponsesInput(state, current) {
     const previous = state.lastRequest;
     const completion = state.lastResponse;
@@ -1291,8 +1211,8 @@ async function webSocketMessageText(value) {
         return Buffer.concat(value).toString('utf8');
     throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model WebSocket returned an unsupported frame.');
 }
-function webSocketHeaders(credential, promptCacheKey, lite = false) {
-    const headers = responsesHeaders(credential, promptCacheKey, undefined, lite);
+function webSocketHeaders(credential, promptCacheKey) {
+    const headers = responsesHeaders(credential, promptCacheKey);
     headers.delete('accept');
     headers.delete('content-type');
     headers.set('openai-beta', 'responses_websockets=2026-02-06');
@@ -1441,8 +1361,8 @@ function responsesEndpoint(baseUrl) {
         return `${normalized}/responses`;
     return `${normalized.endsWith('/v1') ? normalized : `${normalized}/v1`}/responses`;
 }
-async function acquireResponsesCredential(configuration, reason) {
-    return acquireModelCredential(configuration, reason, 'OpenAI Responses requires a model credential.');
+async function acquireResponsesCredential(configuration, reason, signal) {
+    return acquireModelCredential(configuration, reason, 'OpenAI Responses requires a model credential.', signal);
 }
 const RESERVED_CREDENTIAL_HEADERS = new Set([
     'accept',
@@ -1464,9 +1384,9 @@ const RESERVED_CREDENTIAL_HEADERS = new Set([
     'upgrade',
     'x-client-request-id',
     X_CODEX_TURN_STATE,
-    RESPONSES_LITE_HEADER
+    'x-openai-internal-codex-responses-lite'
 ]);
-function responsesHeaders(credential, promptCacheKey, turnState, lite = false) {
+function responsesHeaders(credential, promptCacheKey, turnState) {
     const headers = new Headers({
         authorization: `Bearer ${credential.bearer.reveal()}`,
         'content-type': 'application/json',
@@ -1481,8 +1401,6 @@ function responsesHeaders(credential, promptCacheKey, turnState, lite = false) {
     });
     if (turnState)
         headers.set(X_CODEX_TURN_STATE, turnState);
-    if (lite)
-        headers.set(RESPONSES_LITE_HEADER, 'true');
     return appendModelCredentialHeaders(headers, credential, RESERVED_CREDENTIAL_HEADERS);
 }
 function withCredentialRevision(error, revision) {
@@ -1698,7 +1616,7 @@ function responseCitations(response) {
 function responseEventId(event) {
     return text(record(event.response).id);
 }
-export function openAiInput(messages, images, modelId, requireEncryptedReasoning, nativeToolSearch = true, configurationUpdates = true) {
+export function openAiInput(messages, images, modelId, requireEncryptedReasoning, configurationUpdates = true) {
     const compatibleMessages = messages.filter((message) => message.role !== 'provider' ||
         (message.provider === 'OPENAI_RESPONSES' &&
             (message.providerModelId === undefined || message.providerModelId === modelId) &&
@@ -1708,13 +1626,16 @@ export function openAiInput(messages, images, modelId, requireEncryptedReasoning
                 typeof message.item.encrypted_content === 'string')));
     const lastUser = compatibleMessages.findLast((message) => message.role === 'user');
     const providerCallIds = new Set();
+    const functionCallIds = new Set();
     const customCallIds = new Set();
     const providerMessageTexts = new Set();
     for (const message of compatibleMessages) {
         if (message.role !== 'provider' || !message.item)
             continue;
-        if (message.item.type === 'function_call' && typeof message.item.call_id === 'string')
+        if (message.item.type === 'function_call' && typeof message.item.call_id === 'string') {
             providerCallIds.add(message.item.call_id);
+            functionCallIds.add(message.item.call_id);
+        }
         if (message.item.type === 'tool_search_call' && typeof message.item.call_id === 'string')
             providerCallIds.add(message.item.call_id);
         if (message.item.type === 'custom_tool_call' && typeof message.item.call_id === 'string') {
@@ -1752,20 +1673,13 @@ export function openAiInput(messages, images, modelId, requireEncryptedReasoning
     return orderedMessages
         .filter((message) => !(message.role === 'tool_call' && message.callId && providerCallIds.has(message.callId)) &&
         !(message.role === 'assistant' && providerMessageTexts.has(message.content)))
-        .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds, nativeToolSearch));
+        .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds, functionCallIds));
 }
-function openAiInputItem(message, images, customCallIds = new Set(), nativeToolSearch = true) {
+function openAiInputItem(message, images, customCallIds = new Set(), functionCallIds = new Set()) {
     const userImages = message.role === 'user' ? uniqueModelImages(message.images, images) : [];
     if (message.role === 'provider') {
         if (message.provider !== 'OPENAI_RESPONSES' || !message.item)
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item is invalid.');
-        if (!nativeToolSearch && message.item.type === 'tool_search_call')
-            return {
-                type: 'function_call',
-                call_id: message.item.call_id,
-                name: 'tool_search',
-                arguments: JSON.stringify(message.item.arguments ?? {})
-            };
         if (message.item.type === 'configuration_update') {
             const effort = marAgentReasoningEffortSchema.safeParse(record(message.item.reasoning).effort);
             if (effort.success)
@@ -1783,7 +1697,7 @@ function openAiInputItem(message, images, customCallIds = new Set(), nativeToolS
             name: message.name,
             input: String(message.arguments ?? '')
         };
-    if (nativeToolSearch && message.role === 'tool_call' && message.name === 'tool_search')
+    if (message.role === 'tool_call' && message.name === 'tool_search')
         return {
             type: 'tool_search_call',
             call_id: message.callId,
@@ -1798,7 +1712,9 @@ function openAiInputItem(message, images, customCallIds = new Set(), nativeToolS
             name: message.name,
             arguments: JSON.stringify(message.arguments ?? {})
         };
-    if (nativeToolSearch && message.role === 'tool' && message.toolSearchTools)
+    if (message.role === 'tool' &&
+        message.toolSearchTools &&
+        !functionCallIds.has(message.callId ?? ''))
         return {
             type: 'tool_search_output',
             call_id: message.callId,

package/dist/agent-core/model/runtime-credential.d.ts

@@ -2,5 +2,5 @@ import { SecretValue, type MarAgentModelConfiguration, type ModelCredentialProvi
 export declare function acquireModelCredential(configuration: Pick<MarAgentModelConfiguration, 'apiKey' | 'credentialProvider'> | {
     readonly apiKey?: SecretValue;
     readonly credentialProvider?: ModelCredentialProvider;
-}, reason: ModelCredentialAcquireReason, missingCredentialMessage: string): Promise<ModelCredential>;
+}, reason: ModelCredentialAcquireReason, missingCredentialMessage: string, signal?: AbortSignal): Promise<ModelCredential>;
 export declare function appendModelCredentialHeaders(headers: Headers, credential: ModelCredential, reservedHeaders: ReadonlySet<string>): Headers;

package/dist/agent-core/model/runtime-credential.js

@@ -1,10 +1,12 @@
 import { MarAgentError } from '../error.js';
 import { SecretValue } from './configuration.js';
-export async function acquireModelCredential(configuration, reason, missingCredentialMessage) {
+export async function acquireModelCredential(configuration, reason, missingCredentialMessage, signal) {
+    signal?.throwIfAborted();
     if (configuration.credentialProvider !== undefined) {
         if (configuration.apiKey !== undefined)
             throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model credential sources are ambiguous.');
-        const credential = await configuration.credentialProvider.acquire(reason);
+        const credential = await waitForModelCredential(configuration.credentialProvider, reason, signal);
+        signal?.throwIfAborted();
         if (!Number.isSafeInteger(credential.revision) ||
             credential.revision < 0 ||
             !Number.isFinite(credential.expiresAt) ||
@@ -25,6 +27,26 @@ export async function acquireModelCredential(configuration, reason, missingCrede
         headers: {}
     };
 }
+async function waitForModelCredential(provider, reason, signal) {
+    if (signal === undefined)
+        return provider.acquire(reason);
+    let abort = () => { };
+    try {
+        return await new Promise((resolve, reject) => {
+            // Cancel only this request's wait; the shared provider remains caller-owned.
+            abort = () => reject(signal.reason);
+            signal.addEventListener('abort', abort, { once: true });
+            if (signal.aborted) {
+                abort();
+                return;
+            }
+            provider.acquire(reason).then(resolve, reject);
+        });
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+    }
+}
 export function appendModelCredentialHeaders(headers, credential, reservedHeaders) {
     for (const [name, value] of Object.entries(credential.headers)) {
         if (reservedHeaders.has(name.toLowerCase()))

package/dist/agent-core/runtime/context/gc-tokens.js

@@ -13,7 +13,7 @@ function serializedEntries(input, messages) {
         (input.modelProtocol === undefined &&
             (input.messages ?? messages).some((message) => message.provider === 'OPENAI_RESPONSES'));
     const values = responses
-        ? openAiInput(messages, undefined, input.modelId, true, true, input.responsesConfigurationUpdates !== false)
+        ? openAiInput(messages, undefined, input.modelId, true, input.responsesConfigurationUpdates !== false)
         : messages
             .filter((message) => message.role !== 'provider' ||
             (message.provider === 'ANTHROPIC_MESSAGES' && message.providerModelId === input.modelId))

package/dist/agent-core/sdk/agent.js

@@ -83,6 +83,8 @@ export async function createMarAgentWithAdapter(options) {
         createSession: async (input) => openSession((await store.createSession(input)).id, input.workspace),
         openSession: (id) => openSession(id),
         listSessions: (input) => store.list(input),
+        getSession: (id) => store.getSession(id),
+        setSessionTitle: (id, title, input) => store.updateTitle(id, title, { ...input, automatic: input?.automatic ?? false }, sessionWriterOwner),
         clearSession: async (id) => {
             const runtime = sessionRuntimes.get(id);
             if ([...active.keys()].some((key) => key.startsWith(`${id}:`)))

package/dist/agent-core/sdk/model-runtime.js

@@ -9,10 +9,6 @@ export function resolveAgentModels(configurations, requestedDefaultModelId) {
     for (const model of configuredModels) {
         if ((model.apiKey === undefined) === (model.credentialProvider === undefined))
             throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Exactly one model credential source is required.');
-        if (model.responsesEncoding !== undefined &&
-            (model.protocol !== 'OPENAI_RESPONSES' ||
-                !['STANDARD', 'LITE'].includes(model.responsesEncoding)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses encoding is invalid.');
         if (model.fastMode === true && model.protocol !== 'OPENAI_RESPONSES')
             throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Fast mode requires Responses.');
         if (model.serviceTier !== undefined &&

package/dist/agent-core/sdk/session.js

@@ -6,7 +6,6 @@ import { compactHistoryMayContainRetainedResources, contextualInstructionInsertI
 import { eventForPersistence, publicModelUsage } from '../runtime/event-projection.js';
 import { ExecutionLoop } from '../runtime/execution.js';
 import { closeModelAdapters, createModelTurnSession } from './model-runtime.js';
-import { generateSessionTitle } from './session-title.js';
 import { createSubagentBackend } from './subagent-backend.js';
 import { discoveredMcpToolNames, rebindMcpToolSearchOutputs } from '../tools/mcp/history.js';
 import { currentExecutionImages } from '../tools/output-projection.js';
@@ -193,20 +192,7 @@ export function createSessionOpener(services) {
                 let selectedTurn;
                 const contextGc = new ContextGcRuntime();
                 let selectedAdapter;
-                let titleAdapter;
                 const executionScopedAdapters = new Set();
-                let titleTask;
-                let titleSettled = false;
-                const settleTitle = async () => {
-                    if (titleSettled)
-                        return;
-                    titleSettled = true;
-                    const generatedTitle = await titleTask;
-                    if (generatedTitle)
-                        await store
-                            .updateTitle(sessionId, generatedTitle, { executionId, turnId })
-                            .catch(() => undefined);
-                };
                 const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
                 try {
                     releaseSession = await store.acquireSessionLease(sessionId, sessionWriterOwner);
@@ -331,13 +317,6 @@ export function createSessionOpener(services) {
                         currentExecutionUserIndex = messages.length - 1;
                         internal.delivery?.applied();
                         await appendMailboxMessages();
-                        if (sessionState.automaticTitlePending) {
-                            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);
-                        }
                     }
                     await emit({ type: 'execution.started', mode });
                     if (restored.ignoredImages > 0)
@@ -832,8 +811,7 @@ export function createSessionOpener(services) {
                             const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
                             const residentTools = mcpRegistry.projectDirect(baseTools());
                             const requestTools = (() => {
-                                if (selectedModel.protocol !== 'OPENAI_RESPONSES' ||
-                                    selectedModel.responsesEncoding === 'LITE')
+                                if (selectedModel.protocol !== 'OPENAI_RESPONSES')
                                     return projectCodeModeTools(roundTools, residentTools);
                                 const directNames = new Set(residentTools.map((tool) => tool.name));
                                 // Discovery and caller policy are independent: keep nested declarations for active tools.
@@ -1030,7 +1008,6 @@ export function createSessionOpener(services) {
                         });
                     if (mode === 'compact' && manualCompactionId !== undefined)
                         await emit({ type: 'context.compacted', compactionId: manualCompactionId });
-                    await settleTitle();
                     subagents?.endParentExecution(executionId);
                     await emit({ type: 'execution.completed' });
                     return {
@@ -1042,7 +1019,6 @@ export function createSessionOpener(services) {
                 catch (error) {
                     finalAnswer = executionLoop?.finalAnswer ?? finalAnswer;
                     acceptsMailbox = false;
-                    await settleTitle();
                     if (controller.signal.aborted) {
                         subagents?.endParentExecution(executionId);
                         await emit({ type: 'execution.cancelled' });
@@ -1069,8 +1045,6 @@ export function createSessionOpener(services) {
                         rolloutBudget.discard();
                     await manualCompaction?.dispose();
                     await selectedTurn?.close().catch(() => undefined);
-                    if (titleAdapter !== undefined && titleAdapter !== selectedAdapter)
-                        executionScopedAdapters.add(titleAdapter);
                     try {
                         await closeModelAdapters(executionScopedAdapters);
                     }

package/dist/agent-core/sdk/types.d.ts

@@ -3,11 +3,12 @@ import type { MarAgentModelConfiguration } from '../model/configuration.js';
 import type { ExecutionResult, RolloutBudgetOptions, RunInput } from '../runtime/contracts.js';
 import type { MarAgentEvent } from '../runtime/events.js';
 import type { MarAgentSessionPage, MarAgentSessionSummary } from '../session/catalog.js';
-import type { SessionListInput, SessionSource } from '../session/types.js';
+import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from '../session/types.js';
 export interface CreateSessionInput {
     workspace: string;
     title?: string;
 }
+export type { SessionTitleUpdateInput } from '../session/types.js';
 export type { HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill, MarAgentHost } from '../host/contracts.js';
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from '../runtime/contracts.js';
 export type { MarAgentEvent, MarAgentEventBase } from '../runtime/events.js';
@@ -31,6 +32,10 @@ export interface MarAgent {
     createSession(input: CreateSessionInput): Promise<MarAgentSession>;
     openSession(sessionId: string): Promise<MarAgentSession>;
     listSessions(input?: SessionListInput): Promise<MarAgentSessionPage>;
+    getSession(sessionId: string): Promise<MarAgentSessionSummary & {
+        automaticTitlePending: boolean;
+    }>;
+    setSessionTitle(sessionId: string, title: string, input?: SessionTitleUpdateInput): Promise<boolean>;
     clearSession(sessionId: string): Promise<void>;
     /** Rebinds future main executions only; running subagents keep their captured model providers. */
     reconfigureModels(input: {

package/dist/agent-core/session/jsonl-store.d.ts

@@ -3,7 +3,7 @@ import type { EnvironmentContextState } from '../runtime/context/contracts.js';
 import { type CodeModeStateEntry } from '../tools/code-mode/state.js';
 import { type TodoSnapshot } from '../tools/agent/todo.js';
 import { type ContextGcCheckpointDraft } from './context-gc-checkpoint.js';
-import type { SessionListInput, SessionSource } from './types.js';
+import type { SessionListInput, SessionSource, SessionTitleUpdateInput } from './types.js';
 export type { SessionListInput, SessionSource } from './types.js';
 export interface SessionRecord {
     schemaVersion: 1;
@@ -118,10 +118,7 @@ export declare class JsonlSessionStore {
         lastActivityAt: string;
         source: SessionSource;
     }>;
-    updateTitle(sessionId: string, title: string, input?: {
-        executionId?: string;
-        turnId?: string;
-    }): Promise<void>;
+    updateTitle(sessionId: string, title: string, input?: SessionTitleUpdateInput, owner?: object): Promise<boolean>;
     /** Reset history with the same recovery journal while preserving the Session identity. */
     clearSession(sessionId: string): Promise<{
         id: string;
@@ -138,6 +135,7 @@ export declare class JsonlSessionStore {
         createdAt: string;
         lastActivityAt: string;
         source: SessionSource;
+        automaticTitlePending: boolean;
     }>;
     append(sessionId: string, input: {
         type: string;

package/dist/agent-core/session/jsonl-store.js

@@ -745,21 +745,39 @@ export class JsonlSessionStore {
             await release();
         }
     }
-    async updateTitle(sessionId, title, input = {}) {
+    async updateTitle(sessionId, title, input = {}, owner) {
         this.#assertOpen();
         const normalized = title.trim();
         if (!normalized)
             throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Session title is required.');
-        const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
-        if (!meta)
-            throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-        await this.append(sessionId, {
-            type: 'session.title.updated',
-            payload: { title: normalized, automatic: true },
-            ...(input.executionId ? { executionId: input.executionId } : {}),
-            ...(input.turnId ? { turnId: input.turnId } : {})
-        });
-        meta.title = normalized;
+        const release = await this.acquireSessionLease(sessionId, owner);
+        try {
+            const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
+            if (input.expectedTitle !== undefined && meta.title !== input.expectedTitle)
+                return false;
+            if (input.automatic || input.executionId !== undefined) {
+                const records = await this.read(sessionId);
+                const latestTitle = records.findLast((record) => record.type === 'session.title.updated');
+                if (input.automatic &&
+                    (records[0]?.payload?.automaticTitle !== true ||
+                        latestTitle?.payload?.automatic === false))
+                    return false;
+                if (input.executionId !== undefined &&
+                    records.findLast((record) => record.type === 'turn.user')?.executionId !==
+                        input.executionId)
+                    return false;
+            }
+            await this.append(sessionId, {
+                type: 'session.title.updated',
+                payload: { title: normalized, automatic: input.automatic === true },
+                ...(input.executionId ? { executionId: input.executionId } : {}),
+                ...(input.turnId ? { turnId: input.turnId } : {})
+            });
+            return true;
+        }
+        finally {
+            await release();
+        }
     }
     /** Reset history with the same recovery journal while preserving the Session identity. */
     async clearSession(sessionId) {
@@ -896,7 +914,8 @@ export class JsonlSessionStore {
             workspace: meta.workspace,
             createdAt: meta.createdAt,
             lastActivityAt: meta.lastActivityAt,
-            source: normalizeSessionSource(meta.source)
+            source: normalizeSessionSource(meta.source),
+            automaticTitlePending: meta.automaticTitlePending === true
         };
     }
     async append(sessionId, input) {
@@ -1373,6 +1392,11 @@ export class JsonlSessionStore {
     #applyRecordToResumeIndex(meta, record) {
         if (record.type === 'turn.user')
             meta.automaticTitlePending = false;
+        if (record.type === 'session.title.updated' && isObject(record.payload)) {
+            if (typeof record.payload.title === 'string')
+                meta.title = record.payload.title;
+            meta.automaticTitlePending = false;
+        }
         const resume = meta.resume;
         if (resume?.version !== 1 || !Number.isSafeInteger(resume.todoRevision))
             return;
@@ -2136,6 +2160,8 @@ function deriveExecutionState(records) {
                 record.payload?.automaticTitle === true;
         else if (record.type === 'turn.user')
             sawUserTurn = true;
+        else if (record.type === 'session.title.updated')
+            automaticTitle = false;
         else if (isCompactCheckpoint(record))
             compactSequence = record.sequence;
         else if (record.type === 'todo.updated') {

package/dist/agent-core/session/types.d.ts

@@ -16,3 +16,9 @@ export interface SessionListInput {
     readonly parentSessionId?: string;
     readonly rootSessionId?: string;
 }
+export interface SessionTitleUpdateInput {
+    readonly automatic?: boolean;
+    readonly expectedTitle?: string;
+    readonly executionId?: string;
+    readonly turnId?: string;
+}

package/dist/agent-core/tools/code-mode/cells.js

@@ -81,7 +81,7 @@ export class CodeCells {
             throw new MarAgentError('MAR_AGENT_CODE_CANCELLED', 'Code Exec resources are being released.');
         if ([...this.#cells.values()].filter((cell) => cell.status === 'running').length >=
             limits.codeMaxConcurrentCells)
-            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', 'The Code Exec cell limit was reached.');
+            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', `The Local Host shared running-cell limit (${limits.codeMaxConcurrentCells}) was reached.`);
         const controller = new AbortController();
         const cell = {
             cellId: randomUUID(),

package/dist/agent-core/tools/code-mode/index.js

@@ -218,7 +218,7 @@ export class CodeModeTool {
             throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Code Mode tool dispatch is unavailable.');
         context.signal.throwIfAborted();
         if (this.#active.size >= limits.codeMaxConcurrentCells)
-            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', 'The Code Mode process limit was reached.');
+            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', `The Local Host shared running-cell limit (${limits.codeMaxConcurrentCells}) was reached.`);
         const controller = new AbortController();
         const signal = AbortSignal.any([context.signal, controller.signal]);
         let release;

package/dist/agent-core/tools/code-mode/quickjs-engine.js

@@ -42,14 +42,19 @@ export async function createCodeModeEngine(options) {
                 if (Date.now() >= deadline)
                     throw diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its deadline.');
                 let message = String(error?.message ?? error).slice(0, 4096);
+                const syntaxError = locateSource && error?.name === 'SyntaxError';
+                if (syntaxError)
+                    message = `JavaScript compilation failed before tool execution: ${message}`.slice(0, 4096);
                 const location = locateSource ? compilerSourceLocation(error, input.code) : '';
                 if (location)
                     message = message.slice(0, 4096 - location.length) + location;
                 const code = message.includes('out of memory')
                     ? 'MAR_AGENT_CODE_MEMORY_LIMIT'
-                    : typeof error?.code === 'string'
-                        ? error.code
-                        : 'MAR_AGENT_CODE_FAILED';
+                    : syntaxError
+                        ? 'MAR_AGENT_CODE_SYNTAX_ERROR'
+                        : typeof error?.code === 'string'
+                            ? error.code
+                            : 'MAR_AGENT_CODE_FAILED';
                 throw diagnostic(code, message);
             };
             const guestError = (code, message) => {

package/dist/agent-core/tools/execution-limits.d.ts

@@ -13,7 +13,7 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     execMaxPollYieldMs: 300000;
     execTerminationGraceMs: 1000;
     execDefaultMaxOutputBytes: 1000000;
-    maxProcesses: 8;
+    maxProcesses: 64;
     execMaxCompletedResults: 16;
     execCompletedRetentionMs: 300000;
     codeMaxInputBytes: 1048576;
@@ -21,7 +21,7 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     codeMaxFrameBytes: 33554432;
     codeMaxTransportBytes: 67108864;
     codeMaxCalls: 128;
-    codeMaxConcurrentCells: 4;
+    codeMaxConcurrentCells: 64;
     codeDefaultYieldMs: 30000;
     codeDefaultWaitYieldMs: 10000;
     codeMaxYieldMs: 30000;

package/dist/agent-core/tools/execution-limits.js

@@ -13,7 +13,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     execMaxPollYieldMs: 300_000,
     execTerminationGraceMs: 1_000,
     execDefaultMaxOutputBytes: 1_000_000,
-    maxProcesses: 8,
+    maxProcesses: 64,
     execMaxCompletedResults: 16,
     execCompletedRetentionMs: 300_000,
     codeMaxInputBytes: 1_048_576,
@@ -21,7 +21,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     codeMaxFrameBytes: 33_554_432,
     codeMaxTransportBytes: 67_108_864,
     codeMaxCalls: 128,
-    codeMaxConcurrentCells: 4,
+    codeMaxConcurrentCells: 64,
     codeDefaultYieldMs: 30_000,
     codeDefaultWaitYieldMs: 10_000,
     codeMaxYieldMs: 30_000,

package/dist/agent-core/tools/local/exec.js

@@ -161,7 +161,7 @@ export class ExecTool {
             return result;
         }
         if (this.#processes.size + this.#startingProcesses.size >= this.maxProcesses)
-            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', 'The managed process limit was reached.');
+            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', `The Local Host shared managed-process limit (${this.maxProcesses}) was reached.`);
         let resolveStarting;
         const starting = {
             ...(owner === undefined ? {} : { ownerSessionId: owner.sessionId }),

package/dist/cli/main.js

@@ -12,6 +12,7 @@ import { OpenAiResponsesAdapter } from '../agent-core/model/openai-responses.js'
 import { DEFAULT_COMPACTION_FOCUS } from '../agent-core/runtime/compaction/history.js';
 import { createMarAgent } from '../agent-core/sdk/agent.js';
 import { CodexAuthFileCredentialProvider } from './codex-auth-file.js';
+import { generateSessionTitle } from '../shared/auto-title.js';
 const HELP = `maragent - MAR coding agent
 
 Usage:
@@ -19,7 +20,7 @@ Usage:
   maragent run <prompt> [--reasoning-effort EFFORT] [--format text|json|stream-json] [--codex-auth-file PATH]
   maragent resume [sessionId] [--reasoning-effort EFFORT] [--codex-auth-file PATH]
   maragent sessions list|delete <sessionId>
-  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--high-density-compaction|--no-high-density-compaction] [--responses-encoding standard|lite] [--fast-mode|--no-fast-mode] [--codex-auth-file PATH]
+  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--high-density-compaction|--no-high-density-compaction] [--fast-mode|--no-fast-mode] [--codex-auth-file PATH]
 `;
 function takeOption(arguments_, name) {
     const index = arguments_.indexOf(name);
@@ -62,6 +63,8 @@ async function readApiKey() {
     return value.trim();
 }
 async function modelsCommand(home, arguments_, codexAuthFile) {
+    if (arguments_.includes('--responses-encoding'))
+        throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'Responses encoding is no longer configurable.');
     const action = arguments_[1];
     const catalog = await loadCatalog(home);
     if (action === 'list') {
@@ -140,15 +143,6 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
     if (credential === 'codex-auth-file' && readsApiKey)
         throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', '--api-key-stdin cannot be combined with an external credential.');
     const responsesTransport = parseResponsesTransport(option('--responses-transport'), protocol, existing?.responsesTransport);
-    const encodingOption = option('--responses-encoding');
-    if (encodingOption !== undefined &&
-        (protocol !== 'OPENAI_RESPONSES' || !['standard', 'lite'].includes(encodingOption)))
-        throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', '--responses-encoding is invalid.');
-    const responsesEncoding = protocol === 'OPENAI_RESPONSES'
-        ? (encodingOption?.toUpperCase() ??
-            existing?.responsesEncoding ??
-            'STANDARD')
-        : undefined;
     const reasoningEffortsOption = option('--reasoning-efforts');
     const reasoningEfforts = reasoningEffortsOption === undefined
         ? (existing?.reasoningEfforts ?? [])
@@ -198,7 +192,6 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
             : {}),
         hostedWebSearch: booleanFlag(arguments_, '--web-search', '--no-web-search', existing?.hostedWebSearch ?? false),
         ...(responsesTransport === undefined ? {} : { responsesTransport }),
-        ...(responsesEncoding === undefined ? {} : { responsesEncoding }),
         responsesPreviousResponseId: booleanFlag(arguments_, '--responses-continuation', '--no-responses-continuation', existing?.responsesPreviousResponseId ?? false),
         enabled: booleanFlag(arguments_, '--enabled', '--disabled', existing?.enabled ?? true)
     };
@@ -321,6 +314,8 @@ async function main() {
                 workspace
             });
         let activeHandle;
+        let titleController;
+        let titleTask;
         let interrupts = 0;
         const interrupt = () => {
             interrupts++;
@@ -328,6 +323,7 @@ async function main() {
                 activeHandle.cancel();
             else
                 terminal?.close();
+            titleController?.abort();
             process.exitCode = 130;
             if (interrupts > 1)
                 activeHandle?.cancel();
@@ -345,6 +341,11 @@ async function main() {
                     ...(modelId === undefined ? {} : { modelId }),
                     ...(reasoningEffort === undefined ? {} : { reasoningEffort })
                 };
+                const metadata = !resumeId && invocation.mode !== 'compact'
+                    ? await agent.getSession(session.id).catch(() => undefined)
+                    : undefined;
+                titleController = new AbortController();
+                titleTask = undefined;
                 const handle = invocation.mode === 'plan'
                     ? session.plan(runInput)
                     : invocation.mode === 'compact'
@@ -352,12 +353,33 @@ async function main() {
                         : session.run(runInput);
                 activeHandle = handle;
                 for await (const event of handle) {
+                    if (event.type === 'execution.started' && metadata?.automaticTitlePending && !titleTask)
+                        titleTask = generateSessionTitle({
+                            models: runtime.models,
+                            currentModelId: modelId ??
+                                catalog.defaultModelId ??
+                                runtime.models.find((model) => model.enabled).id,
+                            prompt: invocation.prompt,
+                            signal: titleController.signal
+                        }).catch(() => undefined);
                     if (format === 'stream-json')
                         stdout.write(`${JSON.stringify(event)}\n`);
                     else if (event.type === 'message.delta')
                         stdout.write(event.delta);
                 }
                 const result = await handle.result();
+                if (result.status === 'cancelled')
+                    titleController.abort();
+                const title = await titleTask;
+                if (title && !titleController.signal.aborted)
+                    await agent
+                        .setSessionTitle(session.id, title, {
+                        automatic: true,
+                        expectedTitle: metadata.title,
+                        executionId: handle.executionId
+                    })
+                        .catch(() => undefined);
+                titleController = undefined;
                 activeHandle = undefined;
                 if (format === 'json')
                     stdout.write(`${JSON.stringify(result)}\n`);
@@ -368,6 +390,8 @@ async function main() {
             } while (interactive);
         }
         finally {
+            titleController?.abort();
+            await titleTask;
             process.off('SIGINT', interrupt);
         }
     }
@@ -391,7 +415,6 @@ function runtimeModels(models, codexAuthFile) {
                 : [
                     {
                         ...configuration,
-                        responsesEncoding: configuration.responsesEncoding ?? 'STANDARD',
                         responsesConfigurationUpdates: true,
                         credentialProvider: provider
                     }

package/dist/index.d.ts

@@ -8,7 +8,8 @@ export { testMarAgentModelTransport } from './agent-core/model/transport-test.js
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from './agent-core/runtime/contracts.js';
 export type { MarAgentEvent } from './agent-core/runtime/events.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
-export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, MarAgent, MarAgentSession } from './agent-core/sdk/types.js';
+export { generateSessionTitle, type GenerateSessionTitleInput } from './shared/auto-title.js';
+export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, MarAgent, MarAgentSession, SessionTitleUpdateInput } from './agent-core/sdk/types.js';
 export { openMarAgentSessionCatalog, type MarAgentContextUsage, type MarAgentHistoryEntry, type MarAgentHistoryPage, type MarAgentSessionCatalog, type MarAgentSessionDeleteResult, type MarAgentSessionImage, type MarAgentSessionPage, type MarAgentSessionSummary } from './agent-core/session/catalog.js';
 export type { SessionListInput, SessionSource } from './agent-core/session/types.js';
 export type { ApplyPatchFileResult, ApplyPatchResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';

package/dist/index.js

@@ -4,5 +4,6 @@ export { LocalAgentHost, selectExecutionShell } from './agent-core/host/local-ag
 export { SecretValue, marAgentReasoningEffortSchema, parseModelCatalog, resolveModelDefaultReasoningEffort } from './agent-core/model/configuration.js';
 export { testMarAgentModelTransport } from './agent-core/model/transport-test.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
+export { generateSessionTitle } from './shared/auto-title.js';
 export { openMarAgentSessionCatalog } from './agent-core/session/catalog.js';
 export { MCP_DEFINITION_LIMITS, assertMcpToolCatalog, assertMcpToolDefinition } from './agent-core/tools/mcp/catalog.js';

package/dist/shared/auto-title.d.ts

@@ -0,0 +1,11 @@
+import { type MarAgentModelConfiguration } from '../agent-core/model/configuration.js';
+export interface GenerateSessionTitleInput {
+    readonly models: readonly MarAgentModelConfiguration[];
+    readonly currentModelId: string;
+    readonly prompt: string;
+    /** Used only when the user message does not establish a language. */
+    readonly defaultLanguage?: string;
+    readonly signal: AbortSignal;
+}
+/** Generate a title without a Session or Host. Credential providers remain caller-owned. */
+export declare function generateSessionTitle(input: GenerateSessionTitleInput): Promise<string | undefined>;

package/dist/shared/auto-title.js

@@ -0,0 +1,67 @@
+import { MarAgentError } from '../agent-core/error.js';
+import { AnthropicMessagesAdapter } from '../agent-core/model/anthropic-messages.js';
+import { resolveModelDefaultReasoningEffort } from '../agent-core/model/configuration.js';
+import { OpenAiResponsesAdapter } from '../agent-core/model/openai-responses.js';
+const sessionTitlePrompt = `You are a session title generator. Output only one title and nothing else.
+
+Create a brief title that helps the user find this conversation later.
+- Use the same language as the user message.
+- Output exactly one non-empty line with at most 50 characters.
+- Focus on the main topic or requested outcome.
+- Preserve exact technical terms, numbers, and filenames.
+- Do not answer the request, explain the title, mention tools, or add quotation marks.
+- For a minimal conversational message, still produce a meaningful title reflecting its intent.`;
+/** Generate a title without a Session or Host. Credential providers remain caller-owned. */
+export async function generateSessionTitle(input) {
+    const defaultLanguage = input.defaultLanguage?.trim();
+    if (input.defaultLanguage !== undefined && (!defaultLanguage || defaultLanguage.length > 128))
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Default title language is invalid.');
+    const models = input.models.filter((model) => model.enabled);
+    const model = models.find((candidate) => candidate.titleGeneration) ??
+        models.find((candidate) => candidate.id === input.currentModelId);
+    if (!model)
+        throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'Selected title model is unavailable.');
+    const signal = AbortSignal.any([input.signal, AbortSignal.timeout(30_000)]);
+    signal.throwIfAborted();
+    const adapter = model.protocol === 'OPENAI_RESPONSES'
+        ? new OpenAiResponsesAdapter(model)
+        : new AnthropicMessagesAdapter(model);
+    let titleInput = '';
+    let characters = 0;
+    for (const character of input.prompt) {
+        if (characters++ >= 1000)
+            break;
+        titleInput += character;
+    }
+    let output = '';
+    let completed = false;
+    try {
+        for await (const event of adapter.start({
+            retryState: { attempts: 0, maxAttempts: 1 },
+            system: defaultLanguage
+                ? `${sessionTitlePrompt}\n- If the user message does not establish a language, use ${JSON.stringify(defaultLanguage)} as the default language.`
+                : sessionTitlePrompt,
+            messages: [{ role: 'user', content: titleInput }],
+            tools: [],
+            allowTools: false,
+            reasoningEffort: resolveModelDefaultReasoningEffort(model)
+        }, signal)) {
+            if (event.type === 'text.completed')
+                output = event.text;
+            else if (event.type === 'completed')
+                completed = event.reason === 'completed';
+        }
+        signal.throwIfAborted();
+        if (!completed)
+            return undefined;
+        const line = output
+            .replace(/<think>[\s\S]*?<\/think>\s*/giu, '')
+            .split(/\r?\n/u)
+            .map((value) => value.trim())
+            .find(Boolean);
+        return line ? [...line].slice(0, 50).join('') : undefined;
+    }
+    finally {
+        await adapter.close?.();
+    }
+}

package/package.json

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

package/dist/agent-core/prompts/title.d.ts

@@ -1 +0,0 @@
-export declare const sessionTitlePrompt = "You are a session title generator. Output only one title and nothing else.\n\nCreate a brief title that helps the user find this conversation later.\n- Use the same language as the user message.\n- Output exactly one non-empty line with at most 50 characters.\n- Focus on the main topic or requested outcome.\n- Preserve exact technical terms, numbers, and filenames.\n- Do not answer the request, explain the title, mention tools, or add quotation marks.\n- For a minimal conversational message, still produce a meaningful title reflecting its intent.";

package/dist/agent-core/prompts/title.js

@@ -1,9 +0,0 @@
-export const sessionTitlePrompt = `You are a session title generator. Output only one title and nothing else.
-
-Create a brief title that helps the user find this conversation later.
-- Use the same language as the user message.
-- Output exactly one non-empty line with at most 50 characters.
-- Focus on the main topic or requested outcome.
-- Preserve exact technical terms, numbers, and filenames.
-- Do not answer the request, explain the title, mention tools, or add quotation marks.
-- For a minimal conversational message, still produce a meaningful title reflecting its intent.`;

package/dist/agent-core/sdk/session-title.d.ts

@@ -1,3 +0,0 @@
-import type { MarAgentReasoningEffort } from '../model/configuration.js';
-import type { ModelAdapter, ModelAttemptDiagnostic } from '../model/contracts.js';
-export declare function generateSessionTitle(adapter: ModelAdapter, prompt: string, reasoningEffort: MarAgentReasoningEffort, signal: AbortSignal, onAttemptDiagnostic: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void): Promise<string | undefined>;

package/dist/agent-core/sdk/session-title.js

@@ -1,42 +0,0 @@
-import { sessionTitlePrompt } from '../prompts/title.js';
-import { createModelTurnSession } from './model-runtime.js';
-export async function generateSessionTitle(adapter, prompt, reasoningEffort, signal, onAttemptDiagnostic) {
-    let titleInput = '';
-    let characters = 0;
-    for (const character of prompt) {
-        if (characters++ >= 1000)
-            break;
-        titleInput += character;
-    }
-    let output = '';
-    let completed = false;
-    const turn = createModelTurnSession(adapter);
-    try {
-        for await (const event of turn.start({
-            retryState: { attempts: 0, maxAttempts: 1 },
-            system: sessionTitlePrompt,
-            messages: [{ role: 'user', content: titleInput }],
-            tools: [],
-            reasoningEffort,
-            onAttemptDiagnostic
-        }, signal)) {
-            if (event.type === 'text.completed')
-                output = event.text;
-            else if (event.type === 'completed')
-                completed = event.reason === 'completed';
-        }
-    }
-    finally {
-        await turn.close();
-    }
-    if (!completed)
-        return undefined;
-    const line = output
-        .replace(/<think>[\s\S]*?<\/think>\s*/giu, '')
-        .split(/\r?\n/u)
-        .map((value) => value.trim())
-        .find(Boolean);
-    if (!line)
-        return undefined;
-    return [...line].slice(0, 50).join('');
-}