maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.28.20260911

package/node_modules/@maka/runtime/dist/bots/wechat-bridge.js

@@ -172,10 +172,11 @@ export class WechatBridge extends BaseBotAdapter {
         const baseUrl = normalizeWechatBridgeUrl(this.settings.webhookUrl);
         if (!baseUrl)
             return;
+        const cursor = { sinceEpochSeconds };
         while (this.running) {
             this.abortController = new AbortController();
             try {
-                const response = await proxiedFetch(`${baseUrl}/messages/stream?since=${sinceEpochSeconds}`, {
+                const response = await proxiedFetch(`${baseUrl}/messages/stream?since=${cursor.sinceEpochSeconds}`, {
                     method: 'GET',
                     headers: wechatBridgeHeaders(this.settings),
                     signal: this.abortController.signal,
@@ -183,19 +184,8 @@ export class WechatBridge extends BaseBotAdapter {
                 });
                 if (!response.ok || !response.body)
                     throw new Error(`WeChat stream HTTP ${response.status}`);
-                for await (const raw of readSseJsonObjects(response.body)) {
-                    const messages = Array.isArray(raw) ? raw : [raw];
-                    for (const message of messages) {
-                        const event = mapWechatBridgeMessage(message);
-                        if (!event)
-                            continue;
-                        sinceEpochSeconds = Math.max(sinceEpochSeconds, Math.floor(event.receivedAt / 1000));
-                        this.readiness = 'operational';
-                        this.reason = undefined;
-                        this.emitIncomingMessage(event);
-                        this.emitStatusChange();
-                    }
-                }
+                const messages = readSseJsonObjects(response.body);
+                while (await this.processNextLiveMessages(messages, cursor)) { }
                 if (this.running)
                     await sleep(1_000);
             }
@@ -212,6 +202,31 @@ export class WechatBridge extends BaseBotAdapter {
             }
         }
     }
+    async processNextLiveMessages(stream, cursor) {
+        // Keep the iterator result and mapped events out of the next idle read's frame.
+        const next = await stream.next();
+        if (next.done)
+            return false;
+        try {
+            const messages = Array.isArray(next.value) ? next.value : [next.value];
+            for (const message of messages) {
+                const event = mapWechatBridgeMessage(message);
+                if (!event)
+                    continue;
+                cursor.sinceEpochSeconds = Math.max(cursor.sinceEpochSeconds, Math.floor(event.receivedAt / 1000));
+                this.readiness = 'operational';
+                this.reason = undefined;
+                this.emitIncomingMessage(event);
+                this.emitStatusChange();
+            }
+            return true;
+        }
+        catch (error) {
+            // Match for-await: close after processing failures, preserving the original error.
+            await stream.return(undefined).catch(() => { });
+            throw error;
+        }
+    }
     async streamIlinkMessages(cursor) {
         const baseUrl = normalizeWechatIlinkBaseUrl(this.settings.webhookUrl);
         const token = this.settings.token.trim();
@@ -402,24 +417,67 @@ export function mapWechatIlinkMessage(raw) {
 }
 export async function* readSseJsonObjects(body) {
     const decoder = new TextDecoder();
+    const iterator = body[Symbol.asyncIterator]();
     let buffer = '';
-    for await (const chunk of body) {
-        buffer += decoder.decode(chunk, { stream: true });
-        let boundary = findSseBoundary(buffer);
-        while (boundary) {
-            const event = buffer.slice(0, boundary.index);
-            buffer = buffer.slice(boundary.index + boundary.length);
-            const data = event
-                .split(/\r?\n/)
-                .filter((line) => line.startsWith('data:'))
-                .map((line) => line.slice(5).trimStart())
-                .join('\n')
-                .trim();
-            if (data)
-                yield JSON.parse(data);
-            boundary = findSseBoundary(buffer);
+    let closeIterator = false;
+    try {
+        while (true) {
+            // A rejected next() does not close its iterator under for-await semantics.
+            closeIterator = false;
+            let text = await readSseTextChunk(iterator, decoder);
+            if (text === undefined)
+                return;
+            closeIterator = true;
+            buffer += text;
+            text = undefined;
+            let boundary = findSseBoundary(buffer);
+            while (boundary) {
+                let data = sseEventData(buffer.slice(0, boundary.index));
+                buffer = buffer.slice(boundary.index + boundary.length);
+                if (data)
+                    yield JSON.parse(data);
+                data = '';
+                boundary = findSseBoundary(buffer);
+            }
+        }
+    }
+    catch (error) {
+        if (closeIterator) {
+            closeIterator = false;
+            try {
+                await iterator.return?.();
+            }
+            catch { }
         }
+        throw error;
+    }
+    finally {
+        if (closeIterator)
+            await iterator.return?.();
+    }
+}
+async function readSseTextChunk(iterator, decoder) {
+    const next = await iterator.next();
+    if (next.done)
+        return;
+    try {
+        return decoder.decode(next.value, { stream: true });
     }
+    catch (error) {
+        try {
+            await iterator.return?.();
+        }
+        catch { }
+        throw error;
+    }
+}
+function sseEventData(event) {
+    return event
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).trimStart())
+        .join('\n')
+        .trim();
 }
 export async function testWechatBridge(channel) {
     const baseUrl = normalizeWechatBridgeUrl(channel.webhookUrl);

package/node_modules/@maka/runtime/dist/bots/wecom-bridge.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { WSClient } from '@wecom/aibot-node-sdk';
+import { createRequire } from 'node:module';
 import { BaseBotAdapter, botReadinessFromSettings } from './base-adapter.js';
 const AUTH_TIMEOUT_MS = 15_000;
 /** Detach bridge callbacks before disconnect can synchronously emit. */
@@ -78,36 +78,39 @@ export class WeComBotBridge extends BaseBotAdapter {
             return;
         }
         this.explicitlyStopped = false;
-        const client = new WSClient({
-            botId,
-            secret,
-            maxReconnectAttempts: -1,
-            logger: quietLogger,
-        });
-        this.client = client;
-        this.wire(client, botId);
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            const onAuthenticated = () => finish(resolve);
-            const onError = (error) => finish(() => reject(error));
-            const cleanup = () => {
-                clearTimeout(timer);
-                client.off('authenticated', onAuthenticated);
-                client.off('error', onError);
-            };
-            const finish = (fn) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                fn();
-            };
-            const timer = setTimeout(() => finish(() => reject(new Error('WeCom authentication timed out'))), AUTH_TIMEOUT_MS);
-            client.once('authenticated', onAuthenticated);
-            client.once('error', onError);
-            client.connect();
-        })
-            .then(() => {
+        let startedClient;
+        try {
+            const { WSClient } = createRequire(import.meta.url)('@wecom/aibot-node-sdk');
+            const client = new WSClient({
+                botId,
+                secret,
+                maxReconnectAttempts: -1,
+                logger: quietLogger,
+            });
+            startedClient = client;
+            this.client = client;
+            this.wire(client, botId);
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                const onAuthenticated = () => finish(resolve);
+                const onError = (error) => finish(() => reject(error));
+                const cleanup = () => {
+                    clearTimeout(timer);
+                    client.off('authenticated', onAuthenticated);
+                    client.off('error', onError);
+                };
+                const finish = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    fn();
+                };
+                const timer = setTimeout(() => finish(() => reject(new Error('WeCom authentication timed out'))), AUTH_TIMEOUT_MS);
+                client.once('authenticated', onAuthenticated);
+                client.once('error', onError);
+                client.connect();
+            });
             if (this.explicitlyStopped || this.client !== client)
                 return;
             this.running = true;
@@ -116,17 +119,18 @@ export class WeComBotBridge extends BaseBotAdapter {
             this.reason = undefined;
             this.readiness = 'credentials_valid';
             this.emitStatusChange();
-        })
-            .catch((error) => {
-            if (this.explicitlyStopped || this.client !== client)
+        }
+        catch (error) {
+            if (this.explicitlyStopped || (startedClient && this.client !== startedClient))
                 return;
             this.running = false;
             this.recordFailure(error);
             this.readiness = 'configured';
             this.emitStatusChange();
             this.client = null;
-            closeWeComClient(client);
-        });
+            if (startedClient)
+                closeWeComClient(startedClient);
+        }
     }
     async stop() {
         this.explicitlyStopped = true;

package/node_modules/@maka/runtime/dist/builtin-tools.js

@@ -194,9 +194,28 @@ export function buildBuiltinTools(options = {}) {
                 shell,
                 ...(options.sandboxManager
                     ? {
-                        transformCommand: ({ command, pty, requiredBoundary, ctx }) => sandboxCommand(options.sandboxManager, options.permissionProfile, sandboxPlatform, command, pty, ctx, requiredBoundary, 'background_command'),
+                        transformCommand: ({ command, pty, requiredBoundary, ctx }) => {
+                            const transformed = sandboxCommand(options.sandboxManager, options.permissionProfile, sandboxPlatform, command, pty, ctx, requiredBoundary, 'background_command');
+                            if (!options.shellEnvironment)
+                                return transformed;
+                            return {
+                                ...(transformed ?? { cwd: ctx.cwd }),
+                                env: {
+                                    ...process.env,
+                                    ...transformed?.env,
+                                    ...options.shellEnvironment,
+                                },
+                            };
+                        },
                     }
-                    : {}),
+                    : options.shellEnvironment
+                        ? {
+                            transformCommand: ({ ctx }) => ({
+                                cwd: ctx.cwd,
+                                env: { ...process.env, ...options.shellEnvironment },
+                            }),
+                        }
+                        : {}),
             }),
         ]
         : [

package/node_modules/@maka/runtime/dist/computer-use-tools.js

@@ -945,6 +945,7 @@ export function buildComputerUseTools(deps) {
             release();
             if (invocationQueues.get(sessionId) === current) {
                 invocationQueues.delete(sessionId);
+                presentationGenerations.delete(sessionId);
             }
         }
     }
@@ -2385,7 +2386,9 @@ export function buildComputerUseTools(deps) {
     }
     const tools = [tool];
     tools.clearSession = (sessionId) => {
-        presentationGenerations.set(sessionId, (presentationGenerations.get(sessionId) ?? 0) + 1);
+        if (invocationQueues.has(sessionId)) {
+            presentationGenerations.set(sessionId, (presentationGenerations.get(sessionId) ?? 0) + 1);
+        }
         for (const wake of presentationQueueWaiters.get(sessionId) ?? [])
             wake();
         for (const wake of presentationWaiters.get(sessionId) ?? [])

package/node_modules/@maka/runtime/dist/deep-research-tools.js

@@ -142,14 +142,20 @@ function buildReadArtifactTool(deps) {
             }
             const offset = input.offset_chars ?? 0;
             const maxChars = input.max_chars ?? DEEP_RESEARCH_ARTIFACT_READ_DEFAULT_CHARS;
-            const characters = Array.from(read.text);
-            const end = Math.min(characters.length, offset + maxChars);
-            const chunk = safeResearchArtifactContent(characters.slice(offset, end).join(''));
+            const selected = [];
+            let total = 0;
+            for (const character of read.text) {
+                if (total >= offset && total < offset + maxChars)
+                    selected.push(character);
+                total += 1;
+            }
+            const end = Math.min(total, offset + maxChars);
+            const chunk = safeResearchArtifactContent(selected.join(''));
             return [
-                `<deep-research-artifact id="${ref.artifactId}" role="${ref.role}" offset="${offset}" end="${end}" total="${characters.length}">`,
+                `<deep-research-artifact id="${ref.artifactId}" role="${ref.role}" offset="${offset}" end="${end}" total="${total}">`,
                 `Name: ${normalizeInlineText(ref.name)}`,
                 ...(ref.locator ? [`Locator: ${normalizeInlineText(ref.locator)}`] : []),
-                `Truncated: ${end < characters.length}`,
+                `Truncated: ${end < total}`,
                 '',
                 chunk,
                 '</deep-research-artifact>',

package/node_modules/@maka/runtime/dist/edit-replace.js

@@ -139,10 +139,10 @@ export function computeEditedSource(source, oldString, newString, where) {
     function finish(content, span, replacement, matchedVia) {
         const index = content.indexOf(span);
         const before = content.slice(0, index);
-        const startLine = before.split('\n').length;
+        const startLine = countOccurrences(before, '\n') + 1;
         // A trailing newline in the span is the last line's terminator, not an
         // extra line, so it must not bump endLine.
-        const spanLineCount = span.split('\n').length - (span.endsWith('\n') ? 1 : 0);
+        const spanLineCount = countOccurrences(span, '\n') + 1 - (span.endsWith('\n') ? 1 : 0);
         const endLine = startLine + Math.max(spanLineCount, 1) - 1;
         // slice-join (not String.replace) so `$&`/`$1` in newString are literal.
         const next = before + replacement + content.slice(index + span.length);

package/node_modules/@maka/runtime/dist/filesystem-worker/operations.js

@@ -25,6 +25,7 @@ import { sandboxPathApi } from './sandbox-paths.js';
 import { sandboxBoundaryExpansionAllowsPath } from '@maka/core/sandbox-boundary';
 import { ApplyPatchRejectedError, applyUpdateToContent, createPatchedFile, } from '../apply-patch-file.js';
 import { computeEditedSource } from '../edit-replace.js';
+import { readTextLineWindow } from '../text-line-window.js';
 import { createEditUnifiedDiff, createUnifiedDiff } from '../unified-diff.js';
 import { compareAndDeleteEntry, hostVisibilityAfterWrite, openStableTarget, readModifyWriteThroughHandle, StableWriteFailure, writeThroughHandle, } from '../file-stable-write.js';
 import { isSupportedImagePath, readWorkspaceImage } from '../image-file.js';
@@ -75,12 +76,10 @@ export async function executeFilesystemOperation(operation, operationBoundary, d
                 }
             }
             const content = await fs.readFile(path, 'utf8');
-            if (operation.offset === undefined && operation.limit === undefined)
-                return { kind: 'read', content };
-            const lines = content.split('\n');
-            const start = operation.offset ?? 0;
-            const end = operation.limit ? start + operation.limit : lines.length;
-            return { kind: 'read', content: lines.slice(start, end).join('\n') };
+            return {
+                kind: 'read',
+                content: readTextLineWindow(content, operation.offset, operation.limit),
+            };
         }
         case 'write': {
             const path = await resolveWritableAllowed(operation.cwd, operation.path, 'Write', operationBoundary);

package/node_modules/@maka/runtime/dist/memory-extraction-evidence.js

@@ -273,7 +273,13 @@ function historyRole(event) {
     return event.role === 'model' ? 'assistant' : 'user';
 }
 function sliceCodePoints(value, maximum) {
-    return Array.from(value).slice(0, maximum).join('');
+    const prefix = [];
+    for (const point of value) {
+        if (prefix.length >= maximum)
+            break;
+        prefix.push(point);
+    }
+    return prefix.join('');
 }
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left - right);

package/node_modules/@maka/runtime/dist/memory-extraction.js

@@ -369,7 +369,7 @@ export class MemoryExtractionEngine {
                     return undefined;
                 maximumSplitIndex = requestedTurnStart;
             }
-            const split = memoryRangeSplitCandidates(pendingEntries, maximumSplitIndex).find(({ first, second }) => {
+            const split = findMemoryRangeSplit(pendingEntries, maximumSplitIndex, ({ first, second }) => {
                 const firstThroughOrdinal = first.at(-1).ordinal;
                 const firstTrigger = 'extract';
                 const firstPrepared = this.prepareRange({
@@ -924,9 +924,9 @@ function memorySegmentOperationId(operationId, afterOrdinal, throughOrdinal, por
         .update(JSON.stringify({ operationId, afterOrdinal, throughOrdinal }))
         .digest('hex')}`;
 }
-function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length - 1) {
+function findMemoryRangeSplit(entries, maximumSplitIndex = entries.length - 1, accepts) {
     if (entries.length < 2)
-        return [];
+        return undefined;
     const weights = entries.map(memoryRangeEventWeight);
     const total = weights.reduce((sum, weight) => sum + weight, 0);
     let prefix = 0;
@@ -942,11 +942,16 @@ function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length
         };
     })
         .filter(({ index }) => index <= maximumSplitIndex);
-    return candidates
-        .sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
+    candidates.sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
         left.distance - right.distance ||
-        left.index - right.index)
-        .map(({ index }) => ({ first: entries.slice(0, index), second: entries.slice(index) }));
+        left.index - right.index);
+    // Keep only the candidate being checked; each pair copies the entire range.
+    for (const { index } of candidates) {
+        const split = { first: entries.slice(0, index), second: entries.slice(index) };
+        if (accepts(split))
+            return split;
+    }
+    return undefined;
 }
 function preparedMemoryRangeFits(prepared, trigger) {
     if (!prepared)

package/node_modules/@maka/runtime/dist/openai-responses-websocket.js

@@ -221,11 +221,8 @@ function prepareWireRequest(body, baseline) {
     const { previous_response_id: _previousResponseId, ...currentProperties } = body;
     const fullBody = {
         ...currentProperties,
-        input: [
-            ...structuredClone(baseline.fullBody.input),
-            ...structuredClone(baseline.responseOutput),
-            ...structuredClone(body.input),
-        ],
+        // These JSON values are privately owned; only the combined input array needs to be new.
+        input: [...baseline.fullBody.input, ...baseline.responseOutput, ...body.input],
     };
     const sameProperties = isDeepStrictEqual(requestProperties(baseline.fullBody), requestProperties(fullBody));
     return {

package/node_modules/@maka/runtime/dist/plugin-agent-service.js

@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Service } from './plugin-kernel.js';
+import { pluginInvocationSignal } from './plugin-invocation-signal.js';
+/** Agent registry and invocation carrier exposed to trusted Host plugins. */
+export class PluginAgentService extends Service {
+    invocations = new AsyncLocalStorage();
+    agentRuntime;
+    constructor(ctx) {
+        super(ctx, 'agents');
+        ctx.accessor('agent', {
+            get: () => this.current(),
+        });
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Agent Runtime');
+        if (this.agentRuntime)
+            throw new Error('Plugin Agent Runtime is already bound');
+        this.agentRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.agentRuntime === runtime)
+                this.agentRuntime = undefined;
+        }, 'agents.bindRuntime()');
+    }
+    currentInvocation() {
+        return this.invocations.getStore();
+    }
+    requireInvocation() {
+        const invocation = this.currentInvocation();
+        if (!invocation)
+            throw new Error('This capability requires an active Agent invocation');
+        return invocation;
+    }
+    withInvocation(toolContext, operation) {
+        const invocation = Object.freeze({
+            sessionId: toolContext.sessionId,
+            ...(toolContext.runId ? { runId: toolContext.runId } : {}),
+            turnId: toolContext.turnId,
+            cwd: toolContext.cwd,
+            ...(toolContext.permissionMode ? { permissionMode: toolContext.permissionMode } : {}),
+            ...(toolContext.executionBoundary
+                ? { executionBoundary: toolContext.executionBoundary }
+                : {}),
+            toolCallId: toolContext.toolCallId,
+            abortSignal: toolContext.abortSignal,
+            toolContext,
+        });
+        return this.invocations.run(invocation, operation);
+    }
+    current() {
+        const invocation = this.currentInvocation();
+        if (!invocation)
+            return undefined;
+        return this.handle({
+            id: invocation.sessionId,
+            sessionId: invocation.sessionId,
+            root: true,
+            status: 'running',
+        });
+    }
+    async create(options = {}) {
+        const invocation = this.requireInvocation();
+        return this.handle(await this.runtime().create({ ...options, signal: pluginInvocationSignal(invocation.abortSignal, options.signal) }, invocation), invocation);
+    }
+    async resume(options) {
+        const invocation = this.requireInvocation();
+        return this.handle(await this.runtime().resume({ ...options, signal: pluginInvocationSignal(invocation.abortSignal, options.signal) }, invocation), invocation);
+    }
+    async get(id) {
+        const invocation = this.requireInvocation();
+        const descriptor = await this.runtime().get(assertId(id), invocation);
+        return descriptor ? this.handle(descriptor, invocation) : undefined;
+    }
+    async list() {
+        const invocation = this.requireInvocation();
+        return Object.freeze((await this.runtime().list(invocation)).map((descriptor) => this.handle(descriptor, invocation)));
+    }
+    async roots() {
+        const invocation = this.requireInvocation();
+        return Object.freeze((await this.runtime().roots(invocation)).map((descriptor) => this.handle(descriptor, invocation)));
+    }
+    runtime() {
+        if (!this.agentRuntime)
+            throw new Error('Plugin Agent Runtime is unavailable');
+        return this.agentRuntime;
+    }
+    handle(descriptor, invocation = this.requireInvocation()) {
+        const service = this;
+        const id = assertId(descriptor.id);
+        return Object.freeze({
+            ...descriptor,
+            id,
+            followup: (message) => service.runtime().followup(id, message, invocation),
+            steer: (message) => service.runtime().steer(id, message, invocation),
+            inject: (message) => service.runtime().inject(id, message, invocation),
+            cancel: () => service.runtime().cancel(id, invocation),
+            whenIdle: (signal) => service
+                .runtime()
+                .whenIdle(id, pluginInvocationSignal(invocation.abortSignal, signal), invocation),
+            snapshot: () => service.runtime().snapshot(id, invocation),
+            inbox: () => service.runtime().inbox(id, invocation),
+            result: () => service.runtime().result(id, invocation),
+            artifacts: () => service.runtime().artifacts(id, invocation),
+            transcript: () => service.runtime().transcript(id, invocation),
+            dispose: () => service.runtime().dispose(id, invocation),
+        });
+    }
+}
+function assertId(id) {
+    if (!id || /[\0\r\n]/u.test(id))
+        throw new TypeError('Agent id is invalid');
+    return id;
+}

package/node_modules/@maka/runtime/dist/plugin-approval-service.js

@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Permission request surface backed by Maka's durable Sandbox Boundary authority. */
+export class PluginApprovalService extends Service {
+    agents;
+    constructor(ctx, agents) {
+        super(ctx, 'approval');
+        this.agents = agents;
+    }
+    request(request) {
+        const ask = this.agents.requireInvocation().toolContext?.requestSandboxBoundary;
+        if (!ask)
+            throw new Error('Approval is unavailable on this Agent surface');
+        return ask(request.expansion, request.justification);
+    }
+}