@myagentroam/agent 0.9.132 → 0.9.134

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

@@ -31,6 +31,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     fastMode?: boolean | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
+    responsesToolNamespace?: string | undefined;
     enabled: boolean;
 } | {
     credential: {
@@ -56,5 +57,6 @@ export declare function serializeModel(model: CliModelConfiguration): {
     fastMode?: boolean | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
+    responsesToolNamespace?: string | undefined;
     enabled: boolean;
 };

package/dist/model/configuration.d.ts

@@ -85,6 +85,7 @@ declare const rawModelSchema: z.ZodObject<{
         STANDARD: "STANDARD";
         LITE: "LITE";
     }>>;
+    responsesToolNamespace: z.ZodOptional<z.ZodString>;
     responsesPreviousResponseId: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     enabled: z.ZodBoolean;
 }, z.core.$strict>;

package/dist/model/configuration.js

@@ -54,6 +54,10 @@ const rawModelSchema = z
     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)
+        .optional(),
     responsesPreviousResponseId: z.boolean().optional().default(false),
     enabled: z.boolean()
 })
@@ -90,6 +94,13 @@ const rawModelSchema = z
         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'))
+        context.addIssue({
+            code: 'custom',
+            path: ['responsesToolNamespace'],
+            message: 'Tool namespaces require Standard OpenAI Responses.'
+        });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.fastMode === true)
         context.addIssue({ code: 'custom', message: 'Fast mode requires Responses.' });
 });

package/dist/model/openai-responses.js

@@ -513,7 +513,7 @@ export class OpenAiResponsesAdapter {
                     const status = upstreamHttpStatus(event.status, topLevel.status, record(event.response).status, nested.status);
                     const connectionLimit = this.configuration.responsesTransport?.transport === 'WEBSOCKET' &&
                         isWebSocketConnectionLimitCode(code);
-                    const retryable = connectionLimit || isRetryableUpstreamOverloadCode(code);
+                    const retryable = connectionLimit || isRetryableResponsesUpstreamError(code, message);
                     throw new MarAgentError(code ?? 'MAR_AGENT_MODEL_PROTOCOL_ERROR', message ?? 'OpenAI Responses request failed.', {
                         details: {
                             ...(status === undefined ? {} : { status }),
@@ -852,6 +852,15 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
                 parameters: strictFunctionSchema(tool.inputSchema),
                 strict: true
             });
+    if (configuration.responsesToolNamespace && tools.length > 0) {
+        const nested = tools.splice(0);
+        tools.push({
+            type: 'namespace',
+            name: configuration.responsesToolNamespace,
+            description: 'Client-side agent tools.',
+            tools: nested
+        });
+    }
     if (request.allowTools !== false && configuration.hostedWebSearch)
         tools.push({ type: 'web_search' });
     const toolChoice = request.toolChoice ?? 'auto';
@@ -1306,12 +1315,21 @@ const NON_SEMANTIC_OPENAI_RESPONSES_EVENTS = new Set([
     'response.reasoning_summary_text.delta',
     'responsesapi.websocket_timing'
 ]);
+function isRetryableResponsesUpstreamError(code, message) {
+    if (isRetryableUpstreamOverloadCode(code))
+        return true;
+    if (code !== 'invalid_request_error')
+        return false;
+    // Exact compatibility exception, not a general access/authentication retry rule.
+    const summary = message?.startsWith(`${code}: `) ? message.slice(code.length + 2) : message;
+    return summary === 'Unable to verify Daybreak Blue access. Please try again.';
+}
 export function isOpenAiResponsesRecoverableStreamError(error) {
     return (error instanceof MarAgentError &&
         error.retryable &&
         (error.details?.reason === OPENAI_RESPONSES_EARLY_EOF_REASON ||
             error.details?.reason === OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON ||
-            isRetryableUpstreamOverloadCode(error.code)));
+            isRetryableResponsesUpstreamError(error.code, error.message)));
 }
 function isWebSocketConnectionLimitCode(code) {
     return code?.trim().toLowerCase() === 'websocket_connection_limit_reached';

package/dist/session/catalog.d.ts

@@ -7,6 +7,9 @@ export interface MarAgentSessionSummary {
     createdAt: string;
     lastActivityAt: string;
     source: SessionSource;
+    modelId?: string;
+    modelName?: string;
+    reasoningEffort?: string;
 }
 export interface MarAgentSessionPage {
     sessions: MarAgentSessionSummary[];
@@ -50,6 +53,11 @@ export interface MarAgentSessionImage {
 /** Public session catalog facade. Storage details remain SDK-private. */
 export interface MarAgentSessionCatalog {
     list(input?: SessionListInput): Promise<MarAgentSessionPage>;
+    executionConfiguration(sessionId: string): Promise<{
+        readonly modelId: string;
+        readonly modelName?: string;
+        readonly reasoningEffort?: string;
+    } | undefined>;
     history(sessionId: string, input?: {
         limit?: number;
         cursor?: string;

package/dist/session/catalog.js

@@ -6,6 +6,7 @@ export async function openMarAgentSessionCatalog(input) {
     const store = await JsonlSessionStore.open(input.homeDirectory);
     return {
         list: (options) => store.list(options),
+        executionConfiguration: (sessionId) => store.executionConfiguration(sessionId),
         history: async (sessionId, options = {}) => {
             const beforeSequence = parseCursor(options.cursor);
             const page = await store.readPage(sessionId, {

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

@@ -62,6 +62,10 @@ interface SessionMeta {
         gcBaseSequence?: number;
         todoSequence?: number;
         todoRevision: number;
+        executionModelIndexed?: true;
+        modelId?: string;
+        modelName?: string;
+        reasoningEffort?: string;
     };
     segments?: Array<{
         number: number;
@@ -170,6 +174,9 @@ export declare class JsonlSessionStore {
     list(input?: SessionListInput): Promise<{
         nextCursor?: string;
         sessions: {
+            reasoningEffort?: string;
+            modelName?: string;
+            modelId?: string;
             id: string;
             title: string;
             workspace: string;
@@ -179,6 +186,9 @@ export declare class JsonlSessionStore {
         }[];
     }>;
     listSubagentChildren(parentSessionId: string): Promise<{
+        reasoningEffort?: string;
+        modelName?: string;
+        modelId?: string;
         id: string;
         title: string;
         workspace: string;
@@ -193,6 +203,11 @@ export declare class JsonlSessionStore {
             readonly description: string;
         };
     }[]>;
+    executionConfiguration(sessionId: string): Promise<{
+        readonly modelId: string;
+        readonly modelName?: string;
+        readonly reasoningEffort?: string;
+    } | undefined>;
     sessionTree(sessionId: string): Promise<readonly string[]>;
     delete(sessionId: string): Promise<{
         readonly deleted: boolean;

package/dist/session/jsonl-store.js

@@ -156,7 +156,8 @@ export class JsonlSessionStore {
             indexDirty: false,
             dirtySessionVersions: new Map(),
             pendingPublishIds: new Set(),
-            segments: new Map()
+            segments: new Map(),
+            executionModelReads: new Map()
         };
     }
     /** Merge dirty metadata with disk membership; only createdIds publish locally new entries. */
@@ -264,7 +265,7 @@ export class JsonlSessionStore {
             source: normalizeSessionSource(input.source),
             nextSequence: 1,
             automaticTitlePending: input.title === undefined,
-            resume: { version: 1, todoRevision: 0 },
+            resume: { version: 1, todoRevision: 0, executionModelIndexed: true },
             segments: []
         };
         const publication = await this.#beginUnpublishedSession(id);
@@ -512,7 +513,7 @@ export class JsonlSessionStore {
                 source: { type: 'user' },
                 nextSequence: 1,
                 automaticTitlePending: false,
-                resume: { version: 1, todoRevision: 0 },
+                resume: { version: 1, todoRevision: 0, executionModelIndexed: true },
                 segments: []
             };
             const publication = await this.#beginUnpublishedSession(target.id);
@@ -1166,7 +1167,18 @@ export class JsonlSessionStore {
             workspace: session.workspace,
             createdAt: session.createdAt,
             lastActivityAt: session.lastActivityAt,
-            source: normalizeSessionSource(session.source)
+            source: normalizeSessionSource(session.source),
+            ...(session.resume?.modelId === undefined
+                ? {}
+                : {
+                    modelId: session.resume.modelId,
+                    ...(session.resume.modelName === undefined
+                        ? {}
+                        : { modelName: session.resume.modelName }),
+                    ...(session.resume.reasoningEffort === undefined
+                        ? {}
+                        : { reasoningEffort: session.resume.reasoningEffort })
+                })
         }));
         const next = start + limit < ordered.length
             ? encodeSessionListCursor(this.#shared.index.revision, start + limit, filter)
@@ -1185,9 +1197,42 @@ export class JsonlSessionStore {
             workspace: session.workspace,
             createdAt: session.createdAt,
             lastActivityAt: session.lastActivityAt,
-            source
+            source,
+            ...(session.resume?.modelId === undefined
+                ? {}
+                : {
+                    modelId: session.resume.modelId,
+                    ...(session.resume.modelName === undefined
+                        ? {}
+                        : { modelName: session.resume.modelName }),
+                    ...(session.resume.reasoningEffort === undefined
+                        ? {}
+                        : { reasoningEffort: session.resume.reasoningEffort })
+                })
         }));
     }
+    async executionConfiguration(sessionId) {
+        this.#assertOpen();
+        await this.#refreshIndex();
+        let meta = this.#shared.index.sessions.find((session) => session.id === sessionId);
+        if (meta === undefined)
+            throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+        if (meta.resume?.executionModelIndexed !== true) {
+            await this.#ensureExecutionModelIndexed(sessionId);
+            meta = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (meta === undefined)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+        }
+        return meta.resume?.modelId === undefined
+            ? undefined
+            : {
+                modelId: meta.resume.modelId,
+                ...(meta.resume.modelName === undefined ? {} : { modelName: meta.resume.modelName }),
+                ...(meta.resume.reasoningEffort === undefined
+                    ? {}
+                    : { reasoningEffort: meta.resume.reasoningEffort })
+            };
+    }
     async sessionTree(sessionId) {
         this.#assertOpen();
         await this.#refreshIndex();
@@ -1201,6 +1246,19 @@ export class JsonlSessionStore {
         const resume = meta.resume;
         if (resume?.version !== 1 || !Number.isSafeInteger(resume.todoRevision))
             return;
+        const executionModel = executionModelFromRecord(record);
+        if (executionModel !== undefined) {
+            resume.executionModelIndexed = true;
+            resume.modelId = executionModel.modelId;
+            if (executionModel.modelName === undefined)
+                delete resume.modelName;
+            else
+                resume.modelName = executionModel.modelName;
+            if (executionModel.reasoningEffort === undefined)
+                delete resume.reasoningEffort;
+            else
+                resume.reasoningEffort = executionModel.reasoningEffort;
+        }
         if (isCompactCheckpoint(record)) {
             resume.compactSequence = record.sequence;
             delete resume.gcSequence;
@@ -1273,6 +1331,68 @@ export class JsonlSessionStore {
             contextRecords: state.contextRecords
         };
     }
+    async #ensureExecutionModelIndexed(sessionId) {
+        const pending = this.#shared.executionModelReads.get(sessionId);
+        if (pending !== undefined)
+            return pending;
+        const read = this.#backfillExecutionModel(sessionId).finally(() => {
+            if (this.#shared.executionModelReads.get(sessionId) === read)
+                this.#shared.executionModelReads.delete(sessionId);
+        });
+        this.#shared.executionModelReads.set(sessionId, read);
+        return read;
+    }
+    async #backfillExecutionModel(sessionId) {
+        for (;;) {
+            const before = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (before === undefined)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            if (before.resume?.executionModelIndexed === true)
+                return;
+            const nextSequence = before.nextSequence;
+            const transactionId = before.storageTransactionId;
+            const model = await this.#readLatestExecutionModel(sessionId);
+            // Refresh can replace metadata objects while unrelated sessions are being read.
+            // Merge only into the current entry, and retry if the authoritative history changed.
+            await this.#refreshIndex();
+            const current = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (current === undefined)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            if (current.resume?.executionModelIndexed === true)
+                return;
+            if (current.nextSequence !== nextSequence || current.storageTransactionId !== transactionId)
+                continue;
+            // A missing resume index stays incomplete (no compact boundary); execution
+            // recovery will rebuild it separately instead of doing so during discovery.
+            const resume = (current.resume ??= { version: 1, todoRevision: 0 });
+            resume.executionModelIndexed = true;
+            delete resume.modelId;
+            delete resume.modelName;
+            delete resume.reasoningEffort;
+            if (model !== undefined)
+                Object.assign(resume, model);
+            this.#shared.index.revision++;
+            this.#markIndexDirty(sessionId);
+            return;
+        }
+    }
+    async #readLatestExecutionModel(sessionId) {
+        try {
+            for (const path of (await this.#segmentPaths(sessionId)).reverse())
+                for await (const record of readRecordsFromTail(path)) {
+                    const model = executionModelFromRecord(record);
+                    if (model !== undefined)
+                        return model;
+                }
+            return undefined;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' ||
+                (error instanceof MarAgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND'))
+                return undefined;
+            throw error;
+        }
+    }
     async delete(sessionId) {
         this.#assertOpen();
         await this.#refreshIndex();
@@ -1878,6 +1998,7 @@ function deriveExecutionState(records) {
     let todoSequence;
     let todoRevision = 0;
     let todoItems = [];
+    let executionModel;
     for (const record of records) {
         if (record.type === 'session.created')
             automaticTitle =
@@ -1894,6 +2015,9 @@ function deriveExecutionState(records) {
             todoRevision++;
             todoItems = items;
         }
+        const candidate = executionModelFromRecord(record);
+        if (candidate !== undefined)
+            executionModel = candidate;
     }
     const boundary = records.findLastIndex(isCompactCheckpoint);
     const checkpoint = latestValidContextGcCheckpoint(records);
@@ -1912,10 +2036,28 @@ function deriveExecutionState(records) {
                     gcBaseSequence: contextGcBaseSequence(checkpoint.payload.base)
                 }),
             ...(todoSequence === undefined ? {} : { todoSequence }),
-            todoRevision
+            todoRevision,
+            executionModelIndexed: true,
+            ...(executionModel === undefined ? {} : executionModel)
         }
     };
 }
+function executionModelFromRecord(record) {
+    if (record.type !== 'execution.header' || !isObject(record.payload))
+        return undefined;
+    const modelId = record.payload.modelId;
+    if (typeof modelId !== 'string' || modelId.trim().length === 0)
+        return undefined;
+    const modelName = record.payload.modelName;
+    const reasoningEffort = record.payload.reasoningEffort;
+    return {
+        modelId,
+        ...(typeof modelName === 'string' && modelName.trim().length > 0 ? { modelName } : {}),
+        ...(typeof reasoningEffort === 'string' && reasoningEffort.trim().length > 0
+            ? { reasoningEffort }
+            : {})
+    };
+}
 export function compactSummaryFromCheckpoint(record) {
     if (record?.type !== 'compact.completed')
         return undefined;
@@ -1950,7 +2092,11 @@ function sameResumeIndex(left, right) {
         left.gcGeneration === right.gcGeneration &&
         left.gcBaseSequence === right.gcBaseSequence &&
         left.todoSequence === right.todoSequence &&
-        left.todoRevision === right.todoRevision);
+        left.todoRevision === right.todoRevision &&
+        left.executionModelIndexed === right.executionModelIndexed &&
+        left.modelId === right.modelId &&
+        left.modelName === right.modelName &&
+        left.reasoningEffort === right.reasoningEffort);
 }
 async function readRecords(path) {
     const value = await readFile(path, 'utf8');
@@ -2036,6 +2182,21 @@ async function repairSegmentTail(path) {
     }
 }
 async function readRecordPageFromTail(path, beforeSequence, limit) {
+    const newestFirst = [];
+    for await (const record of readRecordsFromTail(path)) {
+        if (!(record.sequence < beforeSequence))
+            continue;
+        newestFirst.push(record);
+        if (newestFirst.length > limit)
+            break;
+    }
+    return {
+        records: newestFirst.slice(0, limit).reverse(),
+        hasEarlier: newestFirst.length > limit
+    };
+}
+/** Decode complete records newest-first, releasing the file as soon as a reader stops. */
+async function* readRecordsFromTail(path) {
     const handle = await open(path, 'r');
     try {
         const size = (await handle.stat()).size;
@@ -2043,26 +2204,21 @@ async function readRecordPageFromTail(path, beforeSequence, limit) {
         let pendingLineParts = [];
         let invalidFinalLineMayBeIgnored = false;
         let inspectedFileEnd = false;
-        let pageComplete = false;
-        const newestFirst = [];
-        const accept = (line, allowInvalidFinalLine) => {
+        const decode = (line, allowInvalidFinalLine) => {
             if (line.length === 0)
-                return;
-            let record;
+                return undefined;
             try {
-                record = JSON.parse(line.toString('utf8'));
+                return JSON.parse(line.toString('utf8'));
             }
             catch (cause) {
                 if (allowInvalidFinalLine)
-                    return;
+                    return undefined;
                 throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.', {
                     cause
                 });
             }
-            if (record.sequence < beforeSequence)
-                newestFirst.push(record);
         };
-        while (position > 0 && newestFirst.length <= limit) {
+        while (position > 0) {
             const start = Math.max(0, position - REVERSE_READ_CHUNK_BYTES);
             const chunk = Buffer.allocUnsafe(position - start);
             let bytesRead = 0;
@@ -2085,26 +2241,22 @@ async function readRecordPageFromTail(path, beforeSequence, limit) {
                 const line = pendingLineParts.length === 0
                     ? currentPart
                     : Buffer.concat([currentPart, ...pendingLineParts]);
-                accept(line, invalidFinalLineMayBeIgnored);
+                const record = decode(line, invalidFinalLineMayBeIgnored);
                 invalidFinalLineMayBeIgnored = false;
                 pendingLineParts = [];
                 lineEnd = index;
-                if (newestFirst.length > limit) {
-                    pageComplete = true;
-                    break;
-                }
+                if (record !== undefined)
+                    yield record;
             }
-            if (!pageComplete && lineEnd > 0)
+            if (lineEnd > 0)
                 pendingLineParts.unshift(Buffer.from(value.subarray(0, lineEnd)));
             position = start;
         }
-        if (position === 0 && newestFirst.length <= limit && pendingLineParts.length > 0)
-            accept(Buffer.concat(pendingLineParts), invalidFinalLineMayBeIgnored);
-        const hasEarlier = newestFirst.length > limit;
-        return {
-            records: newestFirst.slice(0, limit).reverse(),
-            hasEarlier
-        };
+        if (pendingLineParts.length > 0) {
+            const record = decode(Buffer.concat(pendingLineParts), invalidFinalLineMayBeIgnored);
+            if (record !== undefined)
+                yield record;
+        }
     }
     finally {
         await handle.close();

package/package.json

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