@myagentroam/agent 0.11.21 → 0.11.23

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

@@ -289,7 +289,7 @@ function readKey(input) {
 }
 function readError(path, error) {
     if (error instanceof MarAgentError)
-        return { path, error: { code: error.code, message: error.message } };
+        return { path, error: { code: error.code, message: error.publicMessage } };
     const code = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string'
         ? error.code
         : 'MAR_AGENT_TOOL_FAILED';

package/dist/agent-core/tools/local/view-image.d.ts

@@ -8,4 +8,8 @@ export declare class ViewImageTool {
     constructor(paths: WorkspacePathResolver);
     execute(arguments_: unknown, signal?: AbortSignal): Promise<ToolExecutionResult>;
 }
+/** Resolve Session-owned bytes without using the resource's public URL or original path. */
+export declare function viewResourceImage(arguments_: unknown, readResource: (resourceId: string) => Promise<{
+    dataBase64: string;
+} | undefined>, signal?: AbortSignal): Promise<ToolExecutionResult>;
 export declare function detectImageMime(data: Buffer): ViewImageResult['mimeType'];

package/dist/agent-core/tools/local/view-image.js

@@ -2,17 +2,39 @@ import { createHash } from 'node:crypto';
 import { open } from 'node:fs/promises';
 import { MarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+import { processImage, readImageMetadata } from './image-processing.js';
 export const viewImageToolDefinition = {
     name: 'view_image',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'safe',
-    description: `Read one known local PNG, JPEG, or WebP image and provide its actual pixels to the vision-capable model. Relative paths use the workspace; absolute paths are allowed. The file must be a regular file no larger than ${TOOL_EXECUTION_LIMITS.viewImageMaxBytes} bytes. MIME is detected from file content, not its extension. Use this instead of installing OCR or converting the image through exec.`,
+    description: 'View a PNG, JPEG, or WebP image by path or Session resourceId. Relative paths use the workspace; absolute paths are allowed. Use this tool instead of converting images through exec.',
     inputSchema: {
         type: 'object',
         properties: {
-            path: { type: 'string', description: 'Relative workspace path or absolute image path.' }
+            path: { type: 'string', description: 'Relative workspace path or absolute image path.' },
+            resourceId: { type: 'string', description: 'Session image resource ID, instead of path.' },
+            region: {
+                type: 'object',
+                description: 'For close inspection of a specific area; coordinates use oriented source pixels.',
+                properties: {
+                    x: { type: 'integer', minimum: 0 },
+                    y: { type: 'integer', minimum: 0 },
+                    width: { type: 'integer', minimum: 1 },
+                    height: { type: 'integer', minimum: 1 }
+                },
+                required: ['x', 'y', 'width', 'height'],
+                additionalProperties: false
+            },
+            resize: {
+                type: 'object',
+                description: 'For a smaller overview; fit the image or cropped region within these dimensions without enlargement.',
+                properties: {
+                    maxWidth: { type: 'integer', minimum: 1 },
+                    maxHeight: { type: 'integer', minimum: 1 }
+                },
+                additionalProperties: false
+            }
         },
-        required: ['path'],
         additionalProperties: false
     }
 };
@@ -23,6 +45,8 @@ export class ViewImageTool {
     }
     async execute(arguments_, signal) {
         const input = parseViewImageInput(arguments_);
+        if (input.path === undefined)
+            return invalidInput();
         signal?.throwIfAborted();
         const path = await this.paths.resolve(input.path);
         const handle = await open(path, 'r');
@@ -30,13 +54,22 @@ export class ViewImageTool {
             const stat = await handle.stat({ bigint: true });
             if (!stat.isFile())
                 throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Path is not a regular file.');
-            if (stat.size > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxBytes))
-                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxBytes}-byte limit.`);
+            if (stat.size > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes))
+                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes}-byte source limit. Use an external image tool to reduce it first.`);
+            const hasTransform = input.region !== undefined || input.resize !== undefined;
+            if (!hasTransform && stat.size > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxBytes))
+                throw imageOutputLimit('Image exceeds 3 MiB. Use resize or region.');
             signal?.throwIfAborted();
-            const data = await handle.readFile();
+            const data = Buffer.allocUnsafe(Number(stat.size));
+            let offset = 0;
+            while (offset < data.byteLength) {
+                signal?.throwIfAborted();
+                const { bytesRead } = await handle.read(data, offset, data.byteLength - offset, offset);
+                if (bytesRead === 0)
+                    incompleteImage();
+                offset += bytesRead;
+            }
             signal?.throwIfAborted();
-            if (data.byteLength > TOOL_EXECUTION_LIMITS.viewImageMaxBytes)
-                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxBytes}-byte limit.`);
             const after = await handle.stat({ bigint: true });
             signal?.throwIfAborted();
             if (stat.size !== after.size ||
@@ -44,34 +77,130 @@ export class ViewImageTool {
                 stat.mtimeNs !== after.mtimeNs ||
                 stat.ctimeNs !== after.ctimeNs)
                 return incompleteImage();
-            const mimeType = detectImageMime(data);
-            validateImageContainer(data, mimeType);
-            const metadata = {
-                path: input.path,
-                mimeType,
-                bytes: data.byteLength,
-                sha256: createHash('sha256').update(data).digest('hex')
-            };
-            return {
-                content: `Viewed image ${input.path} (${mimeType}, ${data.byteLength} bytes).`,
-                data: metadata,
-                images: [{ mimeType, dataBase64: data.toString('base64') }]
-            };
+            return await renderViewImage(data, input, signal);
         }
         finally {
             await handle.close();
         }
     }
 }
+/** Resolve Session-owned bytes without using the resource's public URL or original path. */
+export async function viewResourceImage(arguments_, readResource, signal) {
+    const input = parseViewImageInput(arguments_);
+    if (input.resourceId === undefined)
+        return invalidInput();
+    signal?.throwIfAborted();
+    const resource = await readResource(input.resourceId);
+    signal?.throwIfAborted();
+    if (!resource)
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Image resource was not found in this Session.');
+    const data = Buffer.from(resource.dataBase64, 'base64');
+    if (data.length > TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes)
+        throw imageOutputLimit('Image exceeds the source limit.');
+    if (!input.region && !input.resize && data.length > TOOL_EXECUTION_LIMITS.viewImageMaxBytes)
+        throw imageOutputLimit('Image exceeds 3 MiB. Use resize or region.');
+    return renderViewImage(data, input, signal);
+}
+async function renderViewImage(data, input, signal) {
+    const mimeType = detectImageMime(data);
+    validateImageContainer(data, mimeType);
+    const sourceMetadata = await readImageMetadata(data, mimeType, signal);
+    if (input.region &&
+        (input.region.x > sourceMetadata.width ||
+            input.region.y > sourceMetadata.height ||
+            input.region.width > sourceMetadata.width - input.region.x ||
+            input.region.height > sourceMetadata.height - input.region.y))
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Image region is outside the oriented source dimensions.');
+    const visual = input.region !== undefined || input.resize !== undefined
+        ? await processImage(data, sourceMetadata, input, signal)
+        : {
+            bytes: data,
+            width: sourceMetadata.width,
+            height: sourceMetadata.height,
+            mimeType
+        };
+    signal?.throwIfAborted();
+    const resultMetadata = {
+        ...(input.path ? { path: input.path } : { resourceId: input.resourceId }),
+        mimeType: visual.mimeType,
+        bytes: visual.bytes.byteLength,
+        width: visual.width,
+        height: visual.height,
+        ...('sourceWidth' in visual && visual.sourceWidth !== undefined
+            ? { sourceWidth: visual.sourceWidth, sourceHeight: visual.sourceHeight }
+            : {}),
+        ...('region' in visual && visual.region ? { region: visual.region } : {}),
+        sha256: createHash('sha256').update(visual.bytes).digest('hex')
+    };
+    return {
+        content: describeImageResult(resultMetadata),
+        data: resultMetadata,
+        images: [{ mimeType: visual.mimeType, dataBase64: visual.bytes.toString('base64') }]
+    };
+}
 function parseViewImageInput(value) {
     if (!value || typeof value !== 'object')
         return invalidInput();
     const input = value;
-    if (Object.keys(input).some((key) => key !== 'path') ||
-        typeof input.path !== 'string' ||
-        input.path.length === 0)
+    if (Object.keys(input).some((key) => !['path', 'resourceId', 'region', 'resize'].includes(key)) ||
+        (input.path == null) === (input.resourceId == null) ||
+        (input.path != null && (typeof input.path !== 'string' || input.path.length === 0)) ||
+        (input.resourceId != null &&
+            (typeof input.resourceId !== 'string' || input.resourceId.length === 0)))
+        return invalidInput();
+    return {
+        ...(typeof input.path === 'string'
+            ? { path: input.path }
+            : { resourceId: input.resourceId }),
+        ...(input.region == null ? {} : { region: parseRegion(input.region) }),
+        ...(input.resize == null ? {} : { resize: parseResize(input.resize) })
+    };
+}
+function parseRegion(value) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !['x', 'y', 'width', 'height'].includes(key)) ||
+        !Number.isSafeInteger(value.x) ||
+        value.x < 0 ||
+        !Number.isSafeInteger(value.y) ||
+        value.y < 0 ||
+        !isPositiveSafeInteger(value.width) ||
+        !isPositiveSafeInteger(value.height))
+        return invalidInput();
+    return {
+        x: value.x,
+        y: value.y,
+        width: value.width,
+        height: value.height
+    };
+}
+function parseResize(value) {
+    if (!isRecord(value) ||
+        (value.maxWidth == null && value.maxHeight == null) ||
+        Object.keys(value).some((key) => key !== 'maxWidth' && key !== 'maxHeight') ||
+        (value.maxWidth != null && !isPositiveSafeInteger(value.maxWidth)) ||
+        (value.maxHeight != null && !isPositiveSafeInteger(value.maxHeight)))
         return invalidInput();
-    return { path: input.path };
+    return {
+        ...(value.maxWidth == null ? {} : { maxWidth: value.maxWidth }),
+        ...(value.maxHeight == null ? {} : { maxHeight: value.maxHeight })
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPositiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function describeImageResult(result) {
+    const details = [`${result.width}×${result.height} px`, result.mimeType, `${result.bytes} bytes`];
+    if (result.sourceWidth !== undefined && result.sourceHeight !== undefined)
+        details.push(`source ${result.sourceWidth}×${result.sourceHeight} px`);
+    if (result.region)
+        details.push(`region ${result.region.x},${result.region.y} ${result.region.width}×${result.region.height} px`);
+    return `Viewed image ${result.path ?? result.resourceId} (${details.join(', ')}).`;
+}
+function imageOutputLimit(message) {
+    return new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', message);
 }
 export function detectImageMime(data) {
     if (data.length >= 8 &&

package/dist/agent-core/tools/output-projection.d.ts

@@ -3,10 +3,8 @@ import type { ApplyPatchResult, ApplyPatchPartialResult, CodeCellEventData, Exec
 import type { ToolRuntimeImage } from './runtime-context.js';
 import type { SleepResult } from './agent/sleep.js';
 import { type PublicToolMetadata } from './public-metadata.js';
-export declare function currentExecutionImages(modelInputImages: readonly {
-    readonly mimeType: string;
-    readonly dataBase64: string;
-}[] | undefined, toolImages: readonly ToolRuntimeImage[]): ToolRuntimeImage[];
+import type { ModelImage } from '../model/image.js';
+export declare function currentExecutionImages(modelInputImages: readonly ModelImage[] | undefined, toolImages: readonly ToolRuntimeImage[]): ToolRuntimeImage[];
 export declare function boundedModelToolOutput(toolName: string, value: string, data: unknown): {
     content: string;
     truncated: boolean;

package/dist/agent-core/tools/output-projection.js

@@ -6,7 +6,9 @@ import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
 import { publicToolMetadata } from './public-metadata.js';
 export function currentExecutionImages(modelInputImages, toolImages) {
     return [
-        ...(modelInputImages ?? []).map((image) => ({
+        ...(modelInputImages ?? [])
+            .filter((image) => image.dataBase64 !== undefined)
+            .map((image) => ({
             mimeType: image.mimeType,
             data: Buffer.from(image.dataBase64, 'base64')
         })),
@@ -148,15 +150,8 @@ export function structuredToolEventData(toolName, value) {
             }))
         };
     }
-    if (toolName === 'view_image' &&
-        typeof value.path === 'string' &&
-        (value.mimeType === 'image/png' ||
-            value.mimeType === 'image/jpeg' ||
-            value.mimeType === 'image/webp') &&
-        isNonnegativeInteger(value.bytes) &&
-        typeof value.sha256 === 'string' &&
-        /^[a-f0-9]{64}$/u.test(value.sha256))
-        return value;
+    if (toolName === 'view_image')
+        return parseViewImageResult(value);
     if ((toolName === 'exec' || toolName === 'exec_wait') &&
         (value.status === 'running' || value.status === 'completed' || value.status === 'cancelled') &&
         typeof value.stdout === 'string' &&
@@ -175,6 +170,82 @@ export function structuredToolEventData(toolName, value) {
         return parseApplyPatchResult(value);
     return undefined;
 }
+function parseViewImageResult(value) {
+    if (!((typeof value.path === 'string' && value.path.length > 0 && value.resourceId === undefined) ||
+        (typeof value.resourceId === 'string' &&
+            value.resourceId.length > 0 &&
+            value.path === undefined)) ||
+        (value.mimeType !== 'image/png' &&
+            value.mimeType !== 'image/jpeg' &&
+            value.mimeType !== 'image/webp') ||
+        !isPositiveSafeInteger(value.bytes) ||
+        value.bytes > TOOL_EXECUTION_LIMITS.viewImageMaxBytes ||
+        !isPositiveSafeInteger(value.width) ||
+        !isPositiveSafeInteger(value.height) ||
+        !withinImagePixelLimit(value.width, value.height) ||
+        typeof value.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(value.sha256))
+        return undefined;
+    const hasSourceWidth = Object.hasOwn(value, 'sourceWidth');
+    const hasSourceHeight = Object.hasOwn(value, 'sourceHeight');
+    if (hasSourceWidth !== hasSourceHeight)
+        return undefined;
+    if (hasSourceWidth &&
+        (!isPositiveSafeInteger(value.sourceWidth) ||
+            !isPositiveSafeInteger(value.sourceHeight) ||
+            !withinImagePixelLimit(value.sourceWidth, value.sourceHeight) ||
+            value.width > value.sourceWidth ||
+            value.height > value.sourceHeight))
+        return undefined;
+    let region;
+    if (Object.hasOwn(value, 'region')) {
+        if (!isRecord(value.region))
+            return undefined;
+        const candidate = value.region;
+        if (Object.keys(candidate).some((key) => !['x', 'y', 'width', 'height'].includes(key)) ||
+            !isNonnegativeSafeInteger(candidate.x) ||
+            !isNonnegativeSafeInteger(candidate.y) ||
+            !isPositiveSafeInteger(candidate.width) ||
+            !isPositiveSafeInteger(candidate.height) ||
+            !hasSourceWidth ||
+            candidate.x > value.sourceWidth ||
+            candidate.y > value.sourceHeight ||
+            candidate.width > value.sourceWidth - candidate.x ||
+            candidate.height > value.sourceHeight - candidate.y ||
+            value.width > candidate.width ||
+            value.height > candidate.height)
+            return undefined;
+        region = {
+            x: candidate.x,
+            y: candidate.y,
+            width: candidate.width,
+            height: candidate.height
+        };
+    }
+    return {
+        ...(typeof value.path === 'string'
+            ? { path: value.path }
+            : { resourceId: value.resourceId }),
+        mimeType: value.mimeType,
+        bytes: value.bytes,
+        width: value.width,
+        height: value.height,
+        ...(hasSourceWidth
+            ? { sourceWidth: value.sourceWidth, sourceHeight: value.sourceHeight }
+            : {}),
+        ...(region ? { region } : {}),
+        sha256: value.sha256
+    };
+}
+function withinImagePixelLimit(width, height) {
+    return width <= Math.floor(TOOL_EXECUTION_LIMITS.viewImageMaxPixels / height);
+}
+function isPositiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function isNonnegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
 /** Partial patch facts are allowlisted; arbitrary error details never become public event data. */
 export function structuredToolFailureData(toolName, error) {
     return toolName === 'apply_patch' &&

package/dist/agent-core/tools/runtime-context.d.ts

@@ -44,6 +44,7 @@ export interface ToolRuntimeImage {
 }
 export interface ToolRuntimeContext {
     host: MarAgentHost;
+    imageStore?: import('../session/store/contracts.js').SessionStore;
     todo: TodoStore;
     requestSmartCompact?: () => void;
     subagents?: SubagentController;

package/dist/agent-core/tools/runtime.js

@@ -4,6 +4,7 @@ import { AGENT_TOOL_HANDLERS, BUILTIN_TOOL_DEFINITIONS } from './registry.js';
 import { normalizeToolInput } from './input.js';
 import { validateToolResult } from './output-projection.js';
 import { withToolResultExtensions } from './result-extensions.js';
+import { viewResourceImage } from './local/view-image.js';
 export async function executeRegisteredTool(name, arguments_, callId, context, caller = 'direct') {
     return withToolResultExtensions(context.writeToolResultResource, async () => {
         if (context.invokeTool)
@@ -18,6 +19,17 @@ export async function executeCapturedTool(kind, call, context) {
         : undefined;
     if (definition)
         call = { ...call, arguments: normalizeToolInput(call.arguments, definition.inputSchema) };
+    if (kind !== 'mcp' &&
+        call.name === 'view_image' &&
+        call.arguments !== null &&
+        typeof call.arguments === 'object' &&
+        'resourceId' in call.arguments &&
+        call.arguments.resourceId != null) {
+        const store = context.imageStore;
+        if (!store)
+            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Session image resources are unavailable.');
+        return viewResourceImage(call.arguments, (resourceId) => store.readResource(context.sessionId, resourceId), context.signal);
+    }
     if (kind === 'builtin') {
         const handler = AGENT_TOOL_HANDLERS.get(call.name);
         if (handler)
@@ -40,7 +52,14 @@ export async function executeCapturedTool(kind, call, context) {
         sessionId: context.sessionId,
         executionId: context.executionId,
         ...(context.modelId === undefined ? {} : { modelId: context.modelId }),
-        ...(context.recentImages === undefined ? {} : { recentImages: context.recentImages }),
+        ...(context.recentImages === undefined
+            ? {}
+            : {
+                recentImages: context.recentImages.map((image) => ({
+                    ...image,
+                    data: Buffer.from(image.data)
+                }))
+            }),
         ...(context.codeMode === undefined ? {} : { codeMode: context.codeMode })
     });
 }

package/dist/cli/main.js

@@ -155,6 +155,7 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
             .map((effort) => parseReasoningEffort(effort, '--reasoning-efforts'));
     const defaultReasoningEffortOption = option('--default-reasoning-effort');
     const model = {
+        useResourceUrl: existing?.useResourceUrl ?? false,
         id,
         name: required(option('--name', existing?.name), '--name'),
         protocol,
@@ -472,6 +473,6 @@ function parseExecutionInvocation(input) {
 }
 main().catch((error) => {
     const diagnostic = describeMarAgentError(error, 'MAR_AGENT_CLI_FAILED', 'CLI command failed.');
-    process.stderr.write(`${diagnostic.message}\n`);
+    process.stderr.write(`${diagnostic.code}: ${diagnostic.message}\n`);
     process.exitCode = cliExitCode(diagnostic.code);
 });

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { CoreProcessesApi, CoreProcessesBackend, CoreProcessInput, CoreProc
 export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, CompactInput, SteerInput, SteerResult, 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 { SessionStore, SessionStoreMaintenance, SessionStoreSession, SessionRecordInput, SessionStoreCompactInput, SessionRecord, SessionExecutionState, CompactHistoryMessage, CompactUserInput, SessionInputImage, SessionInputImageMetadata, SessionInputImageData, RestoredSessionInputImage, CodeModeStateEntry, TodoSnapshot, TodoItem, CodeToolCallRecord, CodeObservation, ModelMessage, ModelUsage, ModelInputMetadata, ModelTextBlock, ModelContextualBlock, EnvironmentContextState, ContextGcCheckpointDraft, ContextGcBase, ContextGcPlatform, ContextGcEconomicsPolicy, ContextGcMetrics, ContextGcReplacement, ContextGcTarget, ContextGcReadItemReplacement, ContextGcWebToolName, ContextGcSubagentToolName, AvailableToolResultResource } from './agent-core/session/store/contracts.js';
+export type { SessionStore, SessionResource, SessionStoreMaintenance, SessionStoreSession, SessionRecordInput, SessionStoreCompactInput, SessionRecord, SessionExecutionState, CompactHistoryMessage, CompactUserInput, SessionInputImage, SessionInputImageMetadata, SessionInputImageData, RestoredSessionInputImage, CodeModeStateEntry, TodoSnapshot, TodoItem, CodeToolCallRecord, CodeObservation, ModelMessage, ModelUsage, ModelInputMetadata, ModelTextBlock, ModelContextualBlock, EnvironmentContextState, ContextGcCheckpointDraft, ContextGcBase, ContextGcPlatform, ContextGcEconomicsPolicy, ContextGcMetrics, ContextGcReplacement, ContextGcTarget, ContextGcReadItemReplacement, ContextGcWebToolName, ContextGcSubagentToolName, AvailableToolResultResource } from './agent-core/session/store/contracts.js';
 export type { OpenMarAgentSessionCatalogInput } from './agent-core/session/catalog.js';
 export type { ApplyPatchFileResult, ApplyPatchResult, ApplyPatchPartialResult, ClientToolDefinition, MarAgentToolArtifact, MarAgentToolImageArtifact, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './agent-core/tools/contracts.js';
 export { MCP_DEFINITION_LIMITS, assertMcpToolCatalog, assertMcpToolDefinition } from './agent-core/tools/mcp/catalog.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.21",
+  "version": "0.11.23",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,6 +36,7 @@
   "dependencies": {
     "@jitl/quickjs-wasmfile-release-sync": "0.32.0",
     "quickjs-emscripten-core": "0.32.0",
+    "sharp": "0.35.5",
     "undici": "7.29.0",
     "ws": "8.21.3",
     "zod": "4.4.3"