@myagentroam/agent 0.9.145 → 0.9.147

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/index.js

@@ -18,7 +18,10 @@ export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
 - Code Mode Only: call the programmatic tools listed below through tools.NAME inside this tool, including single-tool operations. They are omitted from the top-level tool list. Direct-only tools remain separate model tools and cannot be called here.
-- Use bounded combinations, parallel independent calls, and filtering of large intermediate results to reduce model round trips.
+- Run independent calls concurrently with Promise.all; await sequentially when data, side effects, or failure handling require ordering.
+- Complete known, bounded steps and deterministic result processing in code when this avoids a model round trip. Return to the model when interpretation or a new decision is needed; do not invent extra work to fill a cell.
+- Observe only evidence needed for the next decision or verification: use observe.result for original results, observe.text for derived values, and observe.image for image values. Preserve source and failure details needed for reasoning; keep other intermediate data in the cell.
+- Single-tool cells are valid. Keep loops and retries bounded, and do not blindly replay operations with side effects.
 - Evaluates source in a fresh restricted ECMAScript runtime with top-level await and Promise.all. It is not Node.js or a browser. JavaScript globals do not survive between cells; bounded JSON state is available through state.
 - Accepts raw JavaScript source text, not JSON, quoted strings, or markdown code fences. Responses uses the source directly; Anthropic uses the code field of its tool input object. In either case, do not quote or fence the source again.
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.

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.145",
+  "version": "0.9.147",
   "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('');
-}