@myagentroam/agent 0.9.133 → 0.9.135

package/dist/cli/main.js

@@ -187,6 +187,15 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
         codeMode: booleanFlag(arguments_, '--code-mode', '--no-code-mode', existing?.codeMode ?? false),
         highDensityCompaction: booleanFlag(arguments_, '--high-density-compaction', '--no-high-density-compaction', existing?.highDensityCompaction ?? false),
         ...(credential === 'codex-auth-file' && fastMode ? { fastMode: true } : {}),
+        ...(protocol === 'OPENAI_RESPONSES' && existing?.serviceTier !== undefined
+            ? {
+                serviceTier: hasFastModeOption
+                    ? fastMode
+                        ? 'priority'
+                        : 'default'
+                    : existing.serviceTier
+            }
+            : {}),
         hostedWebSearch: booleanFlag(arguments_, '--web-search', '--no-web-search', existing?.hostedWebSearch ?? false),
         ...(responsesTransport === undefined ? {} : { responsesTransport }),
         ...(responsesEncoding === undefined ? {} : { responsesEncoding }),

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

@@ -29,8 +29,10 @@ export declare function serializeModel(model: CliModelConfiguration): {
     codeMode: boolean;
     highDensityCompaction: boolean;
     fastMode?: boolean | undefined;
+    serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
+    responsesToolNamespace?: string | undefined;
     enabled: boolean;
 } | {
     credential: {
@@ -54,7 +56,9 @@ export declare function serializeModel(model: CliModelConfiguration): {
     codeMode: boolean;
     highDensityCompaction: boolean;
     fastMode?: boolean | undefined;
+    serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
+    responsesToolNamespace?: string | undefined;
     enabled: boolean;
 };

package/dist/model/configuration.d.ts

@@ -71,6 +71,14 @@ declare const rawModelSchema: z.ZodObject<{
     codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     highDensityCompaction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     fastMode: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        auto: "auto";
+        flex: "flex";
+        priority: "priority";
+        fast: "fast";
+        ultrafast: "ultrafast";
+    }>>;
     hostedWebSearch: z.ZodBoolean;
     responsesTransport: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         transport: z.ZodLiteral<"HTTP">;
@@ -85,6 +93,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

@@ -51,9 +51,14 @@ const rawModelSchema = z
     codeMode: z.boolean().optional().default(false),
     highDensityCompaction: z.boolean().optional().default(false),
     fastMode: z.boolean().optional(),
+    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)
+        .optional(),
     responsesPreviousResponseId: z.boolean().optional().default(false),
     enabled: z.boolean()
 })
@@ -90,8 +95,17 @@ 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.' });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.serviceTier !== undefined)
+        context.addIssue({ code: 'custom', message: 'Service tier requires Responses.' });
 });
 export function resolveModelDefaultReasoningEffort(model) {
     const configured = marAgentReasoningEffortSchema.safeParse(model.defaultReasoningEffort);

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';
@@ -878,7 +887,11 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
     }
     return {
         model: configuration.modelId,
-        ...(configuration.fastMode === true ? { service_tier: 'priority' } : {}),
+        ...(configuration.serviceTier !== undefined
+            ? { service_tier: configuration.serviceTier }
+            : configuration.fastMode === true
+                ? { service_tier: 'priority' }
+                : {}),
         ...(lite
             ? {
                 tool_choice: toolChoice,
@@ -1306,12 +1319,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/sdk/agent.js

@@ -1551,6 +1551,10 @@ function resolveAgentModels(configurations, requestedDefaultModelId) {
             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 &&
+            (model.protocol !== 'OPENAI_RESPONSES' ||
+                !['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'].includes(model.serviceTier)))
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses service tier is invalid.');
         if (model.credentialProvider !== undefined)
             credentialProviders.add(model.credentialProvider);
     }

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. */
@@ -1213,11 +1214,15 @@ export class JsonlSessionStore {
     async executionConfiguration(sessionId) {
         this.#assertOpen();
         await this.#refreshIndex();
-        const meta = this.#shared.index.sessions.find((session) => session.id === sessionId);
+        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(meta);
+        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
             : {
@@ -1326,22 +1331,66 @@ export class JsonlSessionStore {
             contextRecords: state.contextRecords
         };
     }
-    async #ensureExecutionModelIndexed(meta) {
-        try {
-            await this.#rebuildExecutionState(meta);
-        }
-        catch (error) {
-            if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_SESSION_NOT_FOUND')
-                throw error;
-            const resume = meta.resume;
-            if (resume?.version !== 1 || !Number.isSafeInteger(resume.todoRevision))
+    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(meta.id);
+            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) {
@@ -2133,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;
@@ -2140,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;
@@ -2182,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.133",
+  "version": "0.9.135",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",