@myagentroam/node 0.9.102 → 0.9.103

package/dist/runner/mar-agent/image-generation.js

@@ -0,0 +1,337 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, isAbsolute, join, posix } from 'node:path';
+import { MarAgentError } from '@myagentroam/agent';
+import { requestHttp, acquireCredential, appendCredentialHeaders } from '@myagentroam/agent/host/network';
+const IMAGE_MAX_BYTES = 20_971_520;
+const RESPONSE_MAX_BYTES = Math.ceil((IMAGE_MAX_BYTES * 4) / 3) + 4096;
+const RESERVED_HEADERS = new Set([
+    'accept',
+    'authorization',
+    'connection',
+    'content-length',
+    'content-type',
+    'host',
+    'proxy-authorization',
+    'transfer-encoding',
+    'x-codex-image-turn-id'
+]);
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const MAX_EDIT_IMAGES = 5;
+const SUPPORTED_EDIT_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp']);
+const IMAGE_GENERATION_RESPONSE_TIMEOUT_MS = 5 * 60 * 1000;
+export const codexImageGenToolDefinition = {
+    name: 'codex_image_gen',
+    agentScope: 'ROOT_ONLY',
+    description: 'Only when the user requests or explicitly authorizes image generation or editing, use the configured Codex Images API. First load and follow skill({name:"codex-imagegen"}); reload if its guidance is no longer in context. Do not generate unsolicited visuals. Omit both selectors for a new image without references. For image inputs, inspect unseen local images with view_image when available; TEXT-only models must not claim visual inspection. Use referenced_image_paths when every image has an absolute path; otherwise use num_last_images_to_include for the smallest sufficient number of currently available conversation images. Never provide both selectors. Include at most five images; if required inputs are missing, ask for them rather than silently omitting them. Recent images are in-memory in the current Execution, not a permanent history library. One PNG is saved in the current Session and its path is returned, not inspected pixels. Use view_image when available to check the result; otherwise report that visual acceptance was not performed. Full workflow guidance is in the codex-imagegen skill.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prompt: { type: 'string', minLength: 1, maxLength: 32_768 },
+            referenced_image_paths: {
+                type: 'array',
+                maxItems: MAX_EDIT_IMAGES,
+                items: {
+                    type: 'string',
+                    description: 'Absolute local path of an image to edit.'
+                }
+            },
+            num_last_images_to_include: {
+                type: 'integer',
+                minimum: 1,
+                maximum: MAX_EDIT_IMAGES,
+                description: 'Number of most recent in-memory conversation images to edit.'
+            }
+        },
+        required: ['prompt'],
+        additionalProperties: false
+    }
+};
+export const bytedArkImageGenToolDefinition = {
+    ...codexImageGenToolDefinition,
+    name: 'byted_ark_image_gen',
+    description: 'Generate or edit one PNG using the configured Ark Images API, only when explicitly requested. First load skill({name:"byted_ark-imagegen"}). Omit both selectors for text-to-image; use absolute referenced_image_paths or num_last_images_to_include for image-to-image, never both. Up to five references, exactly one output; no group generation. Returns a managed image path, not inspected pixels.'
+};
+export async function executeCodexImageGen(arguments_, input) {
+    input.signal.throwIfAborted();
+    const capability = input.configuration.imageGeneration;
+    if (capability === undefined || capability.credentialProvider === undefined)
+        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Image generation requires an independent credential provider.');
+    const request = parseInput(arguments_);
+    const images = await selectedEditImages(request, input);
+    const ark = capability.provider === 'BYTED_ARK';
+    if (!ark && capability.provider !== 'CODEX')
+        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Unsupported image provider.');
+    const endpoint = images.length === 0 ? capability.generateEndpoint : capability.editEndpoint;
+    const body = JSON.stringify(ark
+        ? {
+            model: capability.imageModelId,
+            prompt: request.prompt,
+            ...(images.length === 0
+                ? {}
+                : {
+                    image: images.length === 1
+                        ? `data:${images[0].mimeType};base64,${images[0].data.toString('base64')}`
+                        : images.map((image) => `data:${image.mimeType};base64,${image.data.toString('base64')}`)
+                }),
+            size: '2K',
+            output_format: 'png',
+            response_format: 'b64_json',
+            watermark: false,
+            stream: false,
+            sequential_image_generation: 'disabled'
+        }
+        : {
+            ...(images.length === 0
+                ? {}
+                : {
+                    images: images.map((image) => ({
+                        image_url: `data:${image.mimeType};base64,${image.data.toString('base64')}`
+                    }))
+                }),
+            prompt: request.prompt,
+            background: 'auto',
+            model: capability.imageModelId,
+            n: 1,
+            quality: 'auto',
+            size: 'auto'
+        });
+    const turnId = randomUUID();
+    let reason = 'REQUEST';
+    for (let authenticationAttempt = 0; authenticationAttempt < 2; authenticationAttempt++) {
+        let credentialRevision;
+        const response = await requestHttp(endpoint, async () => {
+            const credential = await waitForImageStep(acquireCredential({ credentialProvider: capability.credentialProvider }, reason, 'Image generation requires a credential.'), input.signal);
+            credentialRevision = credential.revision;
+            const headers = appendCredentialHeaders(new Headers({
+                authorization: `Bearer ${credential.bearer.reveal()}`,
+                accept: 'application/json',
+                'content-type': 'application/json',
+                ...(ark ? {} : { 'x-codex-image-turn-id': turnId })
+            }), credential, RESERVED_HEADERS);
+            return {
+                request: {
+                    method: 'POST',
+                    headers,
+                    body,
+                    redirect: 'manual'
+                },
+                httpVersion: capability.httpVersion,
+                ...(credential.socks5Url === undefined
+                    ? {}
+                    : { socks5Url: credential.socks5Url.reveal() })
+            };
+        }, input.signal, IMAGE_GENERATION_RESPONSE_TIMEOUT_MS);
+        if (!ark && response.status === 401 && authenticationAttempt === 0) {
+            await response.body?.cancel().catch(() => undefined);
+            if (credentialRevision !== undefined)
+                await capability.credentialProvider.invalidate(credentialRevision);
+            reason = 'UNAUTHORIZED';
+            continue;
+        }
+        const payload = await readJsonResponse(response, input.signal);
+        if (!response.ok)
+            throw imageGenerationResponseError(response.status, payload);
+        const encoded = imageBase64(payload);
+        const data = decodePng(encoded);
+        const fileName = generatedFileName(input.callId);
+        const directory = join(input.sessionDirectory, 'generated_images');
+        const path = join(directory, fileName);
+        const displayPath = input.displayDirectory === undefined ? path : posix.join(input.displayDirectory, fileName);
+        input.signal.throwIfAborted();
+        await mkdir(directory, { recursive: true });
+        const temporary = join(directory, `.${fileName}.${randomUUID()}.tmp`);
+        try {
+            input.signal.throwIfAborted();
+            await writeFile(temporary, data, { flag: 'wx', mode: 0o600 });
+            input.signal.throwIfAborted();
+            await rename(temporary, path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        const sha256 = createHash('sha256').update(data).digest('hex');
+        return {
+            content: `Generated image saved to ${displayPath}.\n`,
+            artifacts: [
+                {
+                    kind: 'image',
+                    name: fileName,
+                    mimeType: 'image/png',
+                    byteSize: data.byteLength,
+                    sha256,
+                    fileName
+                }
+            ]
+        };
+    }
+    throw new MarAgentError('MAR_AGENT_IMAGE_GENERATION_FAILED', 'Image generation failed.');
+}
+function parseInput(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return invalidInput();
+    const input = value;
+    const referencedImagePaths = input.referenced_image_paths === null ? undefined : input.referenced_image_paths;
+    const numLastImagesToInclude = input.num_last_images_to_include === null ? undefined : input.num_last_images_to_include;
+    if (Object.keys(input).some((key) => key !== 'prompt' && key !== 'referenced_image_paths' && key !== 'num_last_images_to_include') ||
+        typeof input.prompt !== 'string' ||
+        input.prompt.trim().length === 0 ||
+        input.prompt.length > 32_768 ||
+        (referencedImagePaths !== undefined &&
+            (!Array.isArray(referencedImagePaths) ||
+                referencedImagePaths.length > MAX_EDIT_IMAGES ||
+                referencedImagePaths.some((path) => typeof path !== 'string' || path.length === 0 || path.length > 4096 || !isAbsolute(path)))) ||
+        (numLastImagesToInclude !== undefined &&
+            (!Number.isInteger(numLastImagesToInclude) ||
+                numLastImagesToInclude < 1 ||
+                numLastImagesToInclude > MAX_EDIT_IMAGES)))
+        return invalidInput();
+    const paths = referencedImagePaths;
+    if (paths?.length && numLastImagesToInclude !== undefined)
+        return invalidInput();
+    return {
+        prompt: input.prompt,
+        ...(paths?.length ? { referencedImagePaths: [...paths] } : {}),
+        ...(numLastImagesToInclude === undefined
+            ? {}
+            : { numLastImagesToInclude: numLastImagesToInclude })
+    };
+}
+async function selectedEditImages(request, input) {
+    if (request.referencedImagePaths !== undefined) {
+        const images = [];
+        for (const path of request.referencedImagePaths)
+            images.push(validateEditImage(await input.readImage(path)));
+        return images;
+    }
+    if (request.numLastImagesToInclude === undefined)
+        return [];
+    const images = input.recentImages.slice(-request.numLastImagesToInclude);
+    if (images.length !== request.numLastImagesToInclude)
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', `Requested the last ${request.numLastImagesToInclude} conversation images, but only ${images.length} were available.`);
+    return images.map(validateEditImage);
+}
+function validateEditImage(image) {
+    if (!SUPPORTED_EDIT_MIME_TYPES.has(image.mimeType) ||
+        !Buffer.isBuffer(image.data) ||
+        image.data.byteLength === 0 ||
+        image.data.byteLength > IMAGE_MAX_BYTES)
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Referenced image is invalid or unsupported.');
+    return { mimeType: image.mimeType, data: Buffer.from(image.data) };
+}
+async function readJsonResponse(response, signal) {
+    const contentLength = Number(response.headers.get('content-length'));
+    if (Number.isFinite(contentLength) && contentLength > RESPONSE_MAX_BYTES) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Image response exceeded the size limit.');
+    }
+    if (response.body === null)
+        return {};
+    const reader = response.body.getReader();
+    const abort = () => {
+        void reader.cancel(signal.reason).catch(() => undefined);
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    const chunks = [];
+    let bytes = 0;
+    try {
+        signal.throwIfAborted();
+        for (;;) {
+            const chunk = await reader.read();
+            signal.throwIfAborted();
+            if (chunk.done)
+                break;
+            bytes += chunk.value.byteLength;
+            if (bytes > RESPONSE_MAX_BYTES)
+                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Image response exceeded the size limit.');
+            chunks.push(chunk.value);
+        }
+    }
+    catch (error) {
+        await reader.cancel().catch(() => undefined);
+        throw error;
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks, bytes).toString('utf8'));
+    }
+    catch (cause) {
+        throw new MarAgentError('MAR_AGENT_IMAGE_GENERATION_RESPONSE_INVALID', 'Image response is invalid.', { cause });
+    }
+}
+async function waitForImageStep(operation, signal) {
+    let abort = () => undefined;
+    const interrupted = new Promise((_resolve, reject) => {
+        abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted)
+            abort();
+    });
+    try {
+        return await Promise.race([operation, interrupted]);
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+    }
+}
+function imageBase64(value) {
+    const data = value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Array.isArray(value.data)
+        ? value.data
+        : undefined;
+    const first = data?.length === 1 && data[0] !== null && typeof data[0] === 'object' && !Array.isArray(data[0])
+        ? data[0].b64_json
+        : undefined;
+    if (typeof first !== 'string' || first.length === 0 || first.length > RESPONSE_MAX_BYTES)
+        throw new MarAgentError('MAR_AGENT_IMAGE_GENERATION_RESPONSE_INVALID', 'Image response is invalid.');
+    return first;
+}
+function decodePng(encoded) {
+    if (encoded.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(encoded))
+        throw new MarAgentError('MAR_AGENT_IMAGE_GENERATION_RESPONSE_INVALID', 'Image response is invalid.');
+    const data = Buffer.from(encoded, 'base64');
+    if (data.byteLength === 0 ||
+        data.byteLength > IMAGE_MAX_BYTES ||
+        data.toString('base64') !== encoded ||
+        !data.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE))
+        throw new MarAgentError('MAR_AGENT_IMAGE_GENERATION_RESPONSE_INVALID', 'Image response is not a supported PNG.');
+    return data;
+}
+function generatedFileName(callId) {
+    const normalized = callId
+        .normalize('NFKC')
+        .replace(/[^a-zA-Z0-9._-]+/gu, '_')
+        .replace(/^[_\-.]+|[_\-.]+$/gu, '')
+        .slice(0, 96);
+    const stem = normalized.length > 0 ? normalized : createHash('sha256').update(callId).digest('hex');
+    const fileName = `${stem.startsWith('image_') ? stem : `image_${stem}`}.png`;
+    return basename(fileName);
+}
+function imageGenerationResponseError(status, value) {
+    const error = value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value.error
+        : undefined;
+    const record = error !== null && typeof error === 'object' && !Array.isArray(error)
+        ? error
+        : undefined;
+    const fallbackMessage = `Image generation failed with HTTP ${status}.`;
+    const rawCode = typeof record?.code === 'string' ? record.code.trim() : '';
+    const code = /^[a-zA-Z0-9._-]{1,80}$/u.test(rawCode)
+        ? rawCode
+        : 'MAR_AGENT_IMAGE_GENERATION_FAILED';
+    const rawMessage = typeof record?.message === 'string' ? record.message.trim() : '';
+    const message = rawMessage.length > 0 &&
+        rawMessage.length <= 1_000 &&
+        !/\b(?:authorization|bearer|api[_ -]?key|access[_ -]?token|refresh[_ -]?token|password|secret|proxy-authorization|chatgpt-account-id)\b|socks5:\/\//iu.test(rawMessage)
+        ? rawMessage
+        : fallbackMessage;
+    return new MarAgentError(code, message, { details: { status } });
+}
+function invalidInput() {
+    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Image generation input is invalid.');
+}

package/dist/runner/mar-agent/managed-run-controller.js

@@ -1,8 +1,9 @@
+import { computerUseHostSkill } from './computer-use-skill.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { access, constants } from 'node:fs/promises';
 import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
-import { LocalAgentHost, SecretValue, createMarAgent } from '@myagentroam/agent';
+import { LocalAgentHost, createMarAgent } from '@myagentroam/agent';
 import { marAgentReasoningEffortSchema, marAgentRuntimeModelConfigurationSchema } from '@myagentroam/protocol';
 import { boundedConversationItemId } from '../codex/conversation-parser.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
@@ -10,6 +11,8 @@ import { MarAgentMcpClientCache } from './mcp-client-pool.js';
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
 import { parseRunnerImageAttachments } from '../../util/node-operation-parsers.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
+import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredentialProviders } from './runtime-model-factory.js';
+import { createImageGenerationExtensions } from './image-generation-extensions.js';
 export class MarAgentManagedRunController {
     runner;
     host;
@@ -32,18 +35,13 @@ export class MarAgentManagedRunController {
         this.host = host;
         this.#resourceIdleTtlMs = options.resourceIdleTtlMs ?? 10 * 60_000;
         this.#createAgent = options.createAgent ?? createMarAgent;
-        this.#modelFactory = options.modelFactory ?? {
-            create: (configurations) => configurations.map((configuration) => {
-                const { apiKey, credential, ...model } = configuration;
-                const value = apiKey ?? (credential?.type === 'INLINE_API_KEY' ? credential.value : undefined);
-                if (value === undefined)
-                    throw new Error('MAR_AGENT_RUNTIME_CREDENTIALS_UNSUPPORTED');
-                return {
-                    ...model,
-                    apiKey: new SecretValue(value)
-                };
-            })
-        };
+        this.#modelFactory =
+            options.modelFactory ??
+                new MarAgentRuntimeModelFactory({
+                    resolve: async () => {
+                        throw new Error('MAR_AGENT_RUNTIME_CREDENTIALS_UNSUPPORTED');
+                    }
+                });
         this.#computerUse = options.computerUse;
     }
     dispose() {
@@ -243,6 +241,7 @@ export class MarAgentManagedRunController {
         let executionMcpLease;
         let executionMcpBinding;
         let computerUseBinding;
+        let executionModels = [];
         try {
             const sessionKey = input.externalSessionId ?? input.sessionId;
             const acquisitionKeys = [...new Set([sessionKey, input.sessionId])];
@@ -253,6 +252,7 @@ export class MarAgentManagedRunController {
                 this.#runtimeAcquisitions.set(key, acquisition);
             try {
                 runtime = await acquisition;
+                executionModels = runtime.models;
             }
             finally {
                 for (const key of acquisitionKeys)
@@ -298,17 +298,25 @@ export class MarAgentManagedRunController {
             if (new Set([...userTools, ...nodeTools].map((tool) => tool.name)).size !==
                 userTools.length + nodeTools.length)
                 throw new Error('MAR_AGENT_MCP_TOOL_NAMES_CONFLICT');
-            if (userTools.length > 0 || nodeTools.length > 0)
-                executionMcpBinding = runtime.host.bindExecutionMcp({
-                    tools: [...nodeTools, ...userTools],
-                    call: async (call, signal) => {
-                        if (computerUseBinding?.tools.some((tool) => tool.name === call.name))
-                            return computerUseBinding.call(call, signal);
-                        if (executionMcpLease?.pool.definitions().some((tool) => tool.name === call.name))
-                            return executionMcpLease.pool.call(call.name, call.arguments);
-                        throw new Error('MAR_AGENT_MCP_TOOL_NOT_FOUND');
-                    }
-                });
+            const imageExtensions = createImageGenerationExtensions({
+                configuration: executionModels.find((model) => model.id === input.model.id)
+                    ?.imageGeneration,
+                homeDirectory: homedir(),
+                host: () => runtime.host
+            });
+            executionMcpBinding = runtime.host.bindExecutionExtensions({
+                ...imageExtensions,
+                skills: [...(imageExtensions.skills ?? []), computerUseHostSkill]
+            }, {
+                tools: [...nodeTools, ...userTools],
+                call: async (call, signal) => {
+                    if (computerUseBinding?.tools.some((tool) => tool.name === call.name))
+                        return computerUseBinding.call(call, signal);
+                    if (executionMcpLease?.pool.definitions().some((tool) => tool.name === call.name))
+                        return executionMcpLease.pool.call(call.name, call.arguments);
+                    throw new Error('MAR_AGENT_MCP_TOOL_NOT_FOUND');
+                }
+            });
             const session = runtime.session;
             const reasoningEffort = input.effort
                 ? marAgentReasoningEffortSchema.parse(input.effort)
@@ -372,6 +380,7 @@ export class MarAgentManagedRunController {
             this.#normalizers.delete(input.runId);
             this.host.active.delete(input.runId);
             this.#executions.delete(input.runId);
+            await closeImageCredentialProviders(executionModels);
             await computerUseBinding?.close().catch(() => undefined);
             runtime?.host.unbindExecutionMcp(executionMcpBinding);
             await executionMcpLease?.release().catch(() => undefined);
@@ -425,9 +434,10 @@ export class MarAgentManagedRunController {
                         });
                         try {
                             await existing.agent.reconfigureModels({
-                                models,
+                                models: sdkModelConfigurations(models),
                                 defaultModelId: input.model.id
                             });
+                            existing.models = models;
                         }
                         catch (error) {
                             await closeModelCredentialProviders(models);
@@ -463,6 +473,7 @@ export class MarAgentManagedRunController {
         const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd);
         let agent;
         let runtime;
+        let models = [];
         try {
             const mcp = mcpLease.pool;
             const localHost = new LocalAgentHost({
@@ -481,14 +492,14 @@ export class MarAgentManagedRunController {
                 allowUntrustedTls: allowsUntrustedWebFetchTls(hostConfiguration.environment),
                 resourceIdleTtlMs: this.#resourceIdleTtlMs
             });
-            const models = this.#modelFactory.create(input.models, {
+            models = this.#modelFactory.create(input.models, {
                 ...(input.runtimeScopeId === undefined ? {} : { runtimeScopeId: input.runtimeScopeId }),
                 executionId: input.runId
             });
             agent = await this.#createAgent({
                 mode: 'node',
                 host: localHost,
-                models,
+                models: sdkModelConfigurations(models),
                 defaultModelId: input.model.id,
                 ...(input.personalInstructions ? { systemInstruction: input.personalInstructions } : {})
             });
@@ -502,6 +513,7 @@ export class MarAgentManagedRunController {
                 host: localHost,
                 mcpLease,
                 dynamicCredentials,
+                models,
                 released: false
             };
             this.#sessionRuntimes.set(sessionKey, runtime);
@@ -512,6 +524,7 @@ export class MarAgentManagedRunController {
         }
         catch (error) {
             await agent?.dispose().catch(() => undefined);
+            await closeModelCredentialProviders(models);
             await mcpLease.release().catch(() => undefined);
             throw error;
         }

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -1,5 +1,16 @@
 import { SecretValue } from '@myagentroam/agent';
 import { marAgentRuntimeModelConfigurationSchema, resolveMarAgentDefaultReasoningEffort } from '@myagentroam/protocol';
+export function sdkModelConfigurations(models) {
+    return models.map(({ imageGeneration: _imageGeneration, ...model }) => model);
+}
+export async function closeImageCredentialProviders(models) {
+    const textProviders = new Set(models.map((model) => model.credentialProvider));
+    const imageProviders = new Set(models.flatMap((model) => model.imageGeneration === undefined ||
+        textProviders.has(model.imageGeneration.credentialProvider)
+        ? []
+        : [model.imageGeneration.credentialProvider]));
+    await Promise.allSettled([...imageProviders].map((provider) => provider.close()));
+}
 class PendingCredentialResolution {
     abort;
     initialReason;

package/dist/service/session-message-service.js

@@ -190,10 +190,6 @@ export class SessionMessageService {
             return {
                 session: this.options.present(sessionForPresentation),
                 run: created.run,
-                ...(created.queueItem === undefined &&
-                    (internalMission || missionMessage?.activated === true)
-                    ? { turn: this.options.runtime.conversationTurnForRun(created.run.id) }
-                    : {}),
                 ...(created.queueItem === undefined ? {} : { queueItemId: created.queueItem.id }),
                 delivery,
                 idempotent: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.102",
+  "version": "0.9.103",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.102",
-    "@myagentroam/code-navigation": "0.9.102",
-    "@myagentroam/protocol": "0.9.102"
+    "@myagentroam/agent": "0.9.103",
+    "@myagentroam/code-navigation": "0.9.103",
+    "@myagentroam/protocol": "0.9.103"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"

package/vendor/ctags/NOTICE

@@ -1,10 +1,22 @@
-This directory distributes Universal Ctags 6.2.1 as a separate executable work.
+This directory distributes Universal Ctags binaries as a separate executable
+work. All bundled binaries are official upstream artifacts built from commit
+ab95af198f8eaeb6d50dc96e3adf52e769d3e5f0.
 
 Universal Ctags is licensed under GPL-2.0-or-later. Its complete corresponding
-source is included at source/universal-ctags-6.2.1.tar.gz. The Linux x64 program
-was built without source changes from that archive using configure --disable-xml
-with optional pkg-config dependencies unavailable. The Windows x64 program is
-the upstream universal-ctags/ctags-win32 v6.2.1 ctags-v6.2.1-x64.zip executable.
+source is included at:
 
-The Windows upstream package also distributes the MinGW-w64 runtime, jansson,
-and libyaml license texts copied into licenses/.
+  source/universal-ctags-ab95af198f8eaeb6d50dc96e3adf52e769d3e5f0.tar.gz
+
+The official source URL, per-platform release URLs, archive SHA-256 values and
+executable SHA-256 values are recorded in manifest.json.
+
+Linux x64/ARM64 and macOS x64/ARM64 come from the official
+universal-ctags/ctags-nightly-build 2026.09.16 release. Their upstream package
+metadata and dependency notices are preserved under
+licenses/official-snapshot/<target>/.
+
+Windows x64 comes from the official universal-ctags/ctags-win32
+2026-09-16/p6.2.20260913.0-2-gab95af1 release. Its distributed license texts
+are preserved under licenses/win32-x64/.
+
+No bundled Ctags executable is built by this project.