@qwen-code/arena-agent 0.0.10-dev.8-test.0 → 0.0.10-test.0

package/dist/tools.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, realpathSync } from "node:fs";
 import { open, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { Ajv } from "ajv";
 import addFormats from "ajv-formats";
 import { detect as detectEncoding } from "chardet";
@@ -10,12 +11,16 @@ import mime from "mime/lite";
 import { AskUserHandlerError } from "./ask-user.js";
 import { executeBraveImageSearch, executeBraveWebSearch, } from "./brave-search.js";
 import { CodeToolExecutor } from "./code-tools.js";
+import { schemaOrderedValue } from "./arena-history.js";
+import { ConnectorTools, connectorFailureText } from "./connector-mcp.js";
 import { supportsImageInput } from "./config.js";
 import { extractStructuredDocument, isStructuredDocument, } from "./document-reader.js";
 import { FetchPageReader } from "./fetch-page.js";
 import { replaceFirstText } from "./file-edit.js";
 import { generatedImageBytesForExtension, prepareImageForModel, } from "./image.js";
 import { imageTextFromFallbackModel } from "./image-input-fallback.js";
+import { offerGeneratedImages } from "./image-choice.js";
+import { arenaImageModel, imageOptionModels } from "./image-model.js";
 import { isCodeArenaMode } from "./mode.js";
 import { generateImageWithModelRouter, generateSpeechWithModelRouter, } from "./model-router-media.js";
 import { processManagerForWorkspace, } from "./process-manager.js";
@@ -424,12 +429,22 @@ function receivedType(value) {
         return "array";
     return typeof value;
 }
+function arenaEnumIssue(values, pathParts) {
+    return {
+        code: "invalid_value", values, path: pathParts,
+        message: `Invalid option: expected one of ${values.map((item) => JSON.stringify(item)).join("|")}`,
+    };
+}
 function arenaValidationIssue(error, value) {
     const pathParts = jsonPointerPath(error.instancePath);
     if (error.keyword === "required") {
         const missingProperty = String(error.params.missingProperty);
         const parentSchema = error.parentSchema;
-        const expected = zodTypeName(parentSchema?.properties?.[missingProperty]?.type || "unknown");
+        const missingSchema = parentSchema?.properties?.[missingProperty];
+        if (missingSchema?.enum) {
+            return arenaEnumIssue(missingSchema.enum, [...pathParts, missingProperty]);
+        }
+        const expected = zodTypeName(missingSchema?.type || "unknown");
         return {
             expected,
             code: "invalid_type",
@@ -490,19 +505,11 @@ function arenaValidationIssue(error, value) {
         };
     }
     if (error.keyword === "enum") {
-        const values = error.params.allowedValues;
-        return {
-            code: "invalid_value",
-            values,
-            path: pathParts,
-            message: `Invalid option: expected one of ${values
-                .map((item) => JSON.stringify(item))
-                .join("|")}`,
-        };
+        return arenaEnumIssue(error.params.allowedValues, pathParts);
     }
     if (error.keyword === "format") {
         return {
-            origin: "string",
+            ...(error.params.format === "uri" ? {} : { origin: "string" }),
             code: "invalid_format",
             format: error.params.format === "uri" ? "url" : error.params.format,
             path: pathParts,
@@ -548,8 +555,8 @@ function arenaValidationIssues(error, value) {
     }
     return issues;
 }
-function arenaValidationError(toolName, value, errors) {
-    const issues = (errors || []).flatMap((error) => arenaValidationIssues(error, value));
+function arenaValidationError(toolName, value, errors, customIssues = []) {
+    const issues = (errors || []).flatMap((error) => arenaValidationIssues(error, value)).concat(customIssues);
     return (`Invalid input for tool ${toolName}: Type validation failed: Value: ` +
         `${JSON.stringify(value)}.\nError message: ${JSON.stringify(issues, null, 2)}`);
 }
@@ -593,11 +600,14 @@ async function responseBytes(response, limit = 4 * 1024 * 1024) {
 }
 class ArenaToolExecutor {
     config;
+    interactionBoundaries = new Set();
+    interactionQueue = Promise.resolve();
     workspace;
     workspaceReal;
     tmpReal;
     varTmpReal;
     validators = new Map();
+    connectors;
     pendingVisualContent = new Map();
     askUserHandler;
     imageInputFallbackClient;
@@ -615,6 +625,7 @@ class ArenaToolExecutor {
         // The captured runtime uses Zod object parsing: unknown object keys are
         // stripped before dispatch instead of being emitted as validation issues.
         removeAdditional: "all",
+        useDefaults: true,
     });
     // ask_user needs a handler: TUI/WebUI collect real user input, while
     // headless `-p` may delegate to a configured remote User Agent. add_voice
@@ -634,7 +645,18 @@ class ArenaToolExecutor {
         this.varTmpReal = realpathSync("/var/tmp");
         this.processManager = processManagerForWorkspace(this.workspaceReal);
         this.voiceRegistry = voiceRegistryForWorkspace(this.workspaceReal);
-        this.askUserHandler = options.askUserHandler;
+        const askUserHandler = options.askUserHandler;
+        this.askUserHandler = askUserHandler ? (callId, questions, context) => {
+            // TUI/WebUI own one active question panel. Parallel tools can prepare
+            // auditions concurrently, but must not overwrite another pending answer.
+            const response = this.interactionQueue.then(() => {
+                (this.signal || context?.signal)?.throwIfAborted();
+                this.interactionBoundaries.add(callId);
+                return askUserHandler(callId, questions, context);
+            });
+            this.interactionQueue = response.then(() => { }, () => { });
+            return response;
+        } : undefined;
         this.askUserEnabled = Boolean(options.askUserHandler);
         if (config.imageInputFallbackModel?.trim()) {
             const connection = imageInputFallbackConnection(config);
@@ -646,6 +668,9 @@ class ArenaToolExecutor {
         }
         this.signal = options.signal;
         this.workspaceContext = options.workspaceContext;
+        if ((config.connectors?.length || config.connectedConnectors !== undefined) && !config.disallowedTools?.includes("list_connector_tools")) {
+            this.connectors = new ConnectorTools(config.connectors || [], config.mergeConnectors, config.disallowedTools, options.signal, { workspace: this.workspace, connected: config.connectedConnectors, resolvePath: raw => this.confinedPath(raw) });
+        }
         this.pageReader = new FetchPageReader({ signal: options.signal });
         this.routifyPageReader = new RoutifyFetchPageReader({
             signal: options.signal,
@@ -658,28 +683,66 @@ class ArenaToolExecutor {
             type: "string",
             validate: (value) => URL.canParse(value),
         });
-        for (const definition of toolDefinitions(this.workspaceContext)) {
-            this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
+        for (const definition of toolDefinitions(this.workspaceContext, "arena", config.connectors, config.connectedConnectors)) {
+            const parameters = structuredClone(definition.function.parameters);
+            // The latest wire schema moves this limit into the description. Keep the
+            // documented command bound enforced internally without changing that schema.
+            if (definition.function.name === "bash" || definition.function.name === "start_process") {
+                record(record(parameters.properties).command).maxLength = 64_000;
+            }
+            this.validators.set(definition.function.name, this.ajv.compile(parameters));
         }
     }
     // The tool schemas offered to the model for this session. Identical to the
     // canonical trace set, adjusted for the selected workspace runtime and minus
     // ask_user when no handler is wired. add_voice stays available headlessly.
     availableTools() {
-        let definitions = toolDefinitions(this.workspaceContext);
+        let definitions = this.allDefinitions();
         if (!this.askUserEnabled) {
             definitions = definitions.filter((definition) => definition.function.name !== "ask_user");
         }
         const disallowed = new Set(this.config.disallowedTools || []);
         return definitions.filter((definition) => !disallowed.has(definition.function.name));
     }
+    allDefinitions() {
+        return [...toolDefinitions(this.workspaceContext, "arena", this.config.connectors, this.config.connectedConnectors),
+            ...(this.connectors?.definitions() || [])];
+    }
+    async beginConnectorTurn(history) {
+        await this.connectors?.beginTurn(history);
+    }
+    async closeConnectors() { await this.connectors?.close(); }
+    historyCall(call) {
+        if (call.function.arguments === "")
+            return call;
+        const parsed = this.parseArguments(call);
+        if (parsed.error !== undefined)
+            return call;
+        const name = call.function.name;
+        let value = parsed.value;
+        const validate = this.validators.get(name) || this.connectors?.validator(name);
+        const schema = this.allDefinitions().find(definition => definition.function.name === name)?.function.parameters;
+        if (validate && schema) {
+            const checked = this.validateArguments(name, value, validate);
+            if (checked.validationMessage === undefined)
+                value = this.connectors?.has(name)
+                    ? this.connectors.historyValue(name, checked.value) : schemaOrderedValue(checked.value, schema);
+        }
+        const argumentsText = JSON.stringify(value);
+        return argumentsText === call.function.arguments ? call : { ...call, function: { ...call.function, arguments: argumentsText } };
+    }
+    takeInteractionBoundary(callId) {
+        return this.interactionBoundaries.delete(callId);
+    }
     parseArguments(call) {
         const rawArguments = typeof call.function?.arguments === "string"
             ? call.function.arguments
             : "{}";
         let value;
         try {
-            value = JSON.parse(rawArguments);
+            // Captured empty arguments validate as an empty object, while whitespace
+            // and other incomplete JSON still produce parsing errors.
+            value = JSON.parse(rawArguments === "" ? "{}" : rawArguments);
         }
         catch (error) {
             return { rawArguments, invalidJsonText: rawArguments, error };
@@ -688,6 +751,8 @@ class ArenaToolExecutor {
             ? value.__malformedToolArguments
             : undefined;
         if (typeof malformedArguments === "string") {
+            if (malformedArguments === "")
+                return { rawArguments, value: {} };
             try {
                 JSON.parse(malformedArguments);
             }
@@ -698,12 +763,29 @@ class ArenaToolExecutor {
         return { rawArguments, value };
     }
     validateArguments(name, value, validate) {
-        const validatedArguments = structuredClone(value);
+        let validatedArguments;
+        try {
+            validatedArguments = (this.connectors?.has(name) ? this.connectors.normalizeArguments(name, value) : structuredClone(value));
+        }
+        catch {
+            return { validationMessage: connectorFailureText };
+        }
         if (!validate(validatedArguments)) {
             return {
-                validationMessage: arenaValidationError(name, value, validate.errors),
+                validationMessage: this.connectors?.has(name) ? connectorFailureText : arenaValidationError(name, value, validate.errors),
             };
         }
+        if (name === "ask_user") {
+            const issues = validatedArguments.questions.flatMap((question, index) => {
+                const ids = question.options.map((option) => option.id);
+                return new Set(ids).size === ids.length ? [] : [{
+                        code: "custom", path: ["questions", index, "options"],
+                        message: "Option IDs must be unique within a question",
+                    }];
+            });
+            if (issues.length)
+                return { validationMessage: arenaValidationError(name, value, [], issues) };
+        }
         return { value: validatedArguments };
     }
     inspect(call) {
@@ -713,7 +795,7 @@ class ArenaToolExecutor {
             ? call.function.arguments
             : "{}";
         const parsed = this.parseArguments(call);
-        const validate = this.validators.get(name);
+        const validate = this.validators.get(name) || this.connectors?.validator(name);
         if (this.config.disallowedTools?.includes(name) || !validate) {
             return {
                 id,
@@ -723,7 +805,7 @@ class ArenaToolExecutor {
                 validation: "unknown_tool",
                 validationMessage: this.config.disallowedTools?.includes(name)
                     ? `tool is disallowed: ${name}`
-                    : unavailableToolError(name, toolDefinitions(this.workspaceContext).map((definition) => definition.function.name)),
+                    : this.connectors?.recognizes(name) ? connectorFailureText : unavailableToolError(name, this.allDefinitions().map((definition) => definition.function.name)),
             };
         }
         if (parsed.error !== undefined) {
@@ -732,7 +814,7 @@ class ArenaToolExecutor {
                 name,
                 rawArguments: parsed.rawArguments,
                 validation: "invalid_json",
-                validationMessage: arenaJsonParsingError(name, parsed.invalidJsonText, parsed.error),
+                validationMessage: this.connectors?.has(name) ? connectorFailureText : arenaJsonParsingError(name, parsed.invalidJsonText, parsed.error),
             };
         }
         const validated = this.validateArguments(name, parsed.value, validate);
@@ -771,12 +853,12 @@ class ArenaToolExecutor {
             if (this.config.disallowedTools?.includes(name)) {
                 throw new Error(`tool is disallowed: ${name}`);
             }
-            const validate = this.validators.get(name);
+            const validate = this.validators.get(name) || this.connectors?.validator(name);
             if (!validate) {
                 return {
                     role: "tool",
                     tool_call_id: callId,
-                    content: unavailableToolError(name, toolDefinitions(this.workspaceContext).map((definition) => definition.function.name)),
+                    content: this.connectors?.recognizes(name) ? connectorFailureText : unavailableToolError(name, this.allDefinitions().map((definition) => definition.function.name)),
                 };
             }
             const parsed = this.parseArguments(call);
@@ -784,7 +866,7 @@ class ArenaToolExecutor {
                 return {
                     role: "tool",
                     tool_call_id: callId,
-                    content: arenaJsonParsingError(name, parsed.invalidJsonText, parsed.error),
+                    content: this.connectors?.has(name) ? connectorFailureText : arenaJsonParsingError(name, parsed.invalidJsonText, parsed.error),
                 };
             }
             const argumentsValue = parsed.value;
@@ -843,7 +925,7 @@ class ArenaToolExecutor {
                 return {
                     role: "tool",
                     tool_call_id: callId,
-                    content: json(this.runtimeFailureResult(name, validatedArguments, error, startedAt)),
+                    content: json(this.runtimeFailureResult(name, validatedArguments, error, startedAt, name === "generate_image" ? context?.signal : undefined)),
                 };
             }
             const content = typeof result === "string" ? result : json(result);
@@ -876,20 +958,20 @@ class ArenaToolExecutor {
             };
         }
     }
-    runtimeFailureResult(name, values, error, startedAt) {
-        if (this.signal?.aborted)
+    runtimeFailureResult(name, values, error, startedAt, contextSignal) {
+        if ((this.signal || contextSignal)?.aborted)
             return { status: "aborted" };
         const message = errorMessage(error);
         const durationMs = Date.now() - startedAt;
         if (name === "bash") {
             return {
-                status: "shell_error",
-                stderr: message,
                 stdout: "",
+                stdout_truncated: false,
+                stderr: message,
+                stderr_truncated: false,
                 exit_code: null,
+                status: "shell_error",
                 duration_ms: durationMs,
-                stderr_truncated: false,
-                stdout_truncated: false,
             };
         }
         if (name === "start_process") {
@@ -912,8 +994,8 @@ class ArenaToolExecutor {
         if (name === "get_process_output") {
             return {
                 status: "shell_error",
-                log_tail: message,
                 exit_code: null,
+                log_tail: message,
                 listening_ports: [],
             };
         }
@@ -970,6 +1052,11 @@ class ArenaToolExecutor {
         };
     }
     async dispatch(name, values, toolCallId, context) {
+        if (name === "list_connector_tools" && this.connectors) {
+            return this.connectors.discover(String(values.service));
+        }
+        if (this.connectors?.has(name))
+            return this.connectors.call(name, values);
         // Canned replay responses are served in execute() before schema
         // validation (the lookup consumes entries — single serving point).
         switch (name) {
@@ -985,7 +1072,7 @@ class ArenaToolExecutor {
             case "edit_file":
                 return this.editFile(String(values.path), String(values.old_text), String(values.new_text));
             case "read_file":
-                return this.readWorkspaceFile(String(values.path), toolCallId);
+                return this.readWorkspaceFile(String(values.path), toolCallId, values.offset, values.limit);
             case "fetch_page":
                 return routifyWebFetchEnabled()
                     ? this.routifyPageReader.read(String(values.url), Number(values.chunkIndex || 0))
@@ -1006,7 +1093,7 @@ class ArenaToolExecutor {
                         ? path.resolve(this.workspaceContext.cwd)
                         : "/home/user")), Number(values.startup_wait || 5));
             case "generate_image":
-                return this.generateImage(String(values.file_path), String(values.prompt), values.images);
+                return this.generateImage(String(values.file_path), String(values.prompt), values.images, values.offer_options === true, toolCallId, context);
             case "generate_speech":
                 return this.generateSpeech(String(values.file_path), String(values.text), String(values.voice_id), values.language === undefined ? undefined : String(values.language));
             case "get_process_output":
@@ -1163,9 +1250,8 @@ class ArenaToolExecutor {
         }
         return new Promise((resolve, reject) => {
             const env = this.sandboxEnvironment();
-            // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
-            // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
-            // 必须杀整组，并在宽限期后强制结算兜底。
+            // A process group lets cancellation stop descendants too. A wait timeout
+            // is different: the captured contract permits the command to continue.
             const child = spawn("/bin/bash", ["-lc", command], {
                 cwd: workdir,
                 env,
@@ -1202,10 +1288,8 @@ class ArenaToolExecutor {
                 clearTimeout(timeout);
                 if (forceSettle)
                     clearTimeout(forceSettle);
-                // bash is one-shot in v2. Any descendant left in the process group is
-                // cleaned up even when the shell itself exited normally; persistent
-                // servers belong in start_process.
-                killTree("SIGKILL");
+                if (!timedOut || this.signal?.aborted)
+                    killTree("SIGKILL");
                 this.signal?.removeEventListener("abort", abort);
                 if (this.signal?.aborted) {
                     reject(this.signal.reason || new Error("operation cancelled"));
@@ -1214,13 +1298,13 @@ class ArenaToolExecutor {
                 const out = stdout.result();
                 const err = stderr.result();
                 resolve({
-                    status: timedOut ? "timeout" : signal ? "killed" : "completed",
-                    stderr: err.text,
                     stdout: out.text,
+                    stdout_truncated: out.truncated,
+                    stderr: err.text,
+                    stderr_truncated: err.truncated,
                     exit_code: timedOut ? null : code,
+                    status: timedOut ? "timeout" : signal ? "killed" : "completed",
                     duration_ms: Date.now() - startedAt,
-                    stderr_truncated: err.truncated,
-                    stdout_truncated: out.truncated,
                 });
             };
             // 宽限期结束时升级为组级 SIGKILL 再结算：abort 只发 SIGTERM，
@@ -1233,8 +1317,12 @@ class ArenaToolExecutor {
             };
             const timeout = setTimeout(() => {
                 timedOut = true;
-                killTree("SIGKILL");
-                armForceSettle();
+                finish(null, null);
+                // Keep draining the pipes so a continuing command cannot block or get
+                // SIGPIPE. Do not keep the host CLI alive just to collect discarded output.
+                child.unref();
+                child.stdout.unref?.();
+                child.stderr.unref?.();
             }, timeoutSeconds * 1000);
             const abort = () => {
                 killTree("SIGTERM");
@@ -1242,10 +1330,12 @@ class ArenaToolExecutor {
             };
             this.signal?.addEventListener("abort", abort, { once: true });
             child.stdout.on("data", (chunk) => {
-                stdout.append(chunk);
+                if (!settled)
+                    stdout.append(chunk);
             });
             child.stderr.on("data", (chunk) => {
-                stderr.append(chunk);
+                if (!settled)
+                    stderr.append(chunk);
             });
             child.once("error", (error) => {
                 if (settled)
@@ -1389,7 +1479,7 @@ class ArenaToolExecutor {
         }
         return { status: "success", message: `Edited ${rawPath}.` };
     }
-    async readWorkspaceFile(rawPath, toolCallId) {
+    async readWorkspaceFile(rawPath, toolCallId, offset, limit) {
         let target;
         let fileSize;
         let sample;
@@ -1472,7 +1562,10 @@ class ArenaToolExecutor {
             return result;
         }
         if (kind === "text") {
-            const text = readTextResult(data);
+            const start = (offset ?? 1) - 1;
+            const selected = offset === undefined && limit === undefined ? data
+                : Buffer.from(decodeText(data).split("\n").slice(start, limit === undefined ? undefined : start + limit).join("\n"), "utf8");
+            const text = readTextResult(selected);
             return {
                 kind: "text",
                 lines: data.reduce((count, byte) => count + (byte === 0x0a ? 1 : 0), 1),
@@ -1554,7 +1647,15 @@ class ArenaToolExecutor {
         return { status: "success" };
     }
     async webSearch(query, depth) {
-        return executeBraveWebSearch(query, depth, { signal: this.signal });
+        const result = await executeBraveWebSearch(query, depth, { signal: this.signal });
+        // Keep the shared provider/Code Arena envelope unchanged. Agent Arena's
+        // live history emits title before URL; restored history has its own order.
+        if (!Array.isArray(result.results))
+            return result;
+        return { ...result, results: result.results.map(value => {
+                const { id, title, url, ...rest } = record(value);
+                return { id, title, url, ...rest };
+            }) };
     }
     async imageSearch(query, count) {
         const payload = await executeBraveImageSearch(query, count, {
@@ -1602,10 +1703,10 @@ class ArenaToolExecutor {
                     mkdirSync(path.dirname(target), { recursive: true });
                     await writeFile(target, await responseBytes(imageResponse));
                     saved.push({
-                        title: stringValue(item.title),
                         file_path: this.relativePath(target),
-                        source_url: sourceUrl,
                         thumbnail_url: thumbnailUrl,
+                        title: stringValue(item.title),
+                        source_url: sourceUrl,
                     });
                     break;
                 }
@@ -1630,13 +1731,13 @@ class ArenaToolExecutor {
             const target = await this.confinedPath(rawPath);
             if (!(await stat(target)).isFile())
                 throw new Error(rawPath);
-            return { path: rawPath, status: "success" };
+            return { status: "success", path: rawPath };
         }
         catch {
             return { status: "error", message: "Error calling present file tool" };
         }
     }
-    async generateImage(rawPath, prompt, images) {
+    async generateImage(rawPath, prompt, images, offerOptions = false, toolCallId = "generate_image", context) {
         if (!rawPath) {
             return { status: "error", message: "File path cannot be empty." };
         }
@@ -1648,8 +1749,8 @@ class ArenaToolExecutor {
                 message: "File path must end in .jpg, .jpeg, or .png.",
             };
         }
-        mkdirSync(path.dirname(target), { recursive: true });
-        const model = process.env.ARENA_IMAGE_MODEL || "gemini-3.1-flash-image";
+        if (!offerOptions)
+            mkdirSync(path.dirname(target), { recursive: true });
         const references = [];
         for (const imagePath of images || []) {
             const source = await this.confinedPath(imagePath);
@@ -1674,14 +1775,26 @@ class ArenaToolExecutor {
                 mimeType,
             });
         }
-        const generated = await generateImageWithModelRouter({
-            images: references,
-            model,
-            prompt,
-            signal: this.signal,
-            size: process.env.ARENA_IMAGE_SIZE || "1024*1024",
-        });
-        await writeFile(target, await generatedImageBytesForExtension(generated.bytes, generated.mimeType, extension));
+        const size = process.env.ARENA_IMAGE_SIZE || "1024*1024";
+        const generate = async (imageModel) => {
+            const generated = await generateImageWithModelRouter({
+                images: references, model: imageModel, prompt, signal: this.signal || context?.signal, size,
+            });
+            return generatedImageBytesForExtension(generated.bytes, generated.mimeType, extension);
+        };
+        if (offerOptions) {
+            const models = imageOptionModels();
+            return offerGeneratedImages({
+                workspace: this.workspaceReal, stateRoot: this.config.stateRoot,
+                target, rawPath, callId: toolCallId, context,
+                signal: this.signal || context?.signal, models, generate,
+                fingerprint: JSON.stringify({ target, rawPath, prompt, size, models,
+                    images: references.map(image => ({ mimeType: image.mimeType,
+                        sha256: createHash("sha256").update(image.bytes).digest("hex") })) }),
+                askUser: this.askUserHandler, confinedPath: filePath => this.confinedPath(filePath),
+            });
+        }
+        await writeFile(target, await generate(arenaImageModel()));
         return {
             status: "success",
             file_path: rawPath,
@@ -1746,6 +1859,20 @@ export class ToolExecutor {
     availableTools() {
         return this.implementation.availableTools();
     }
+    historyCall(call) {
+        return this.implementation instanceof ArenaToolExecutor ? this.implementation.historyCall(call) : call;
+    }
+    takeInteractionBoundary(callId) {
+        return this.implementation instanceof ArenaToolExecutor && this.implementation.takeInteractionBoundary(callId);
+    }
+    async beginConnectorTurn(history) {
+        if (this.implementation instanceof ArenaToolExecutor)
+            await this.implementation.beginConnectorTurn(history);
+    }
+    async closeConnectors() {
+        if (this.implementation instanceof ArenaToolExecutor)
+            await this.implementation.closeConnectors();
+    }
     inspect(call) {
         return this.implementation.inspect(call);
     }