@meshagent/meshagent 0.41.4 → 0.41.5

package/dist/browser/agent.js

@@ -1,67 +1,250 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteTaskRunner = exports.HostedToolkit = exports.Toolkit = exports.Tool = void 0;
+exports.RemoteTaskRunner = exports.HostedToolkit = exports.Toolkit = exports.Tool = exports.ContentTool = exports.FunctionTool = exports.BaseTool = exports.ToolStreamOutput = exports.ToolContentOutput = exports.ToolCallOutput = exports.ToolStreamInput = exports.ToolContentInput = exports.ToolInput = exports.RoomToolContext = exports.ToolContext = exports.InvalidToolDataException = void 0;
 exports.startHostedToolkit = startHostedToolkit;
 const response_1 = require("./response");
 const room_server_client_1 = require("./room-server-client");
 const tool_content_type_1 = require("./tool-content-type");
 const utils_1 = require("./utils");
 const room_event_1 = require("./room-event");
-class Tool {
-    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema }) {
+const participant_1 = require("./participant");
+const stream_controller_1 = require("./stream-controller");
+class InvalidToolDataException extends room_server_client_1.RoomServerException {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidToolDataException";
+    }
+}
+exports.InvalidToolDataException = InvalidToolDataException;
+class ToolContext {
+    constructor({ caller, onBehalfOf } = {}) {
+        this.caller = caller;
+        this.onBehalfOf = onBehalfOf;
+    }
+}
+exports.ToolContext = ToolContext;
+class RoomToolContext extends ToolContext {
+    constructor({ room, caller, onBehalfOf }) {
+        super({ caller, onBehalfOf });
+        this.room = room;
+    }
+}
+exports.RoomToolContext = RoomToolContext;
+class ToolInput {
+}
+exports.ToolInput = ToolInput;
+class ToolContentInput extends ToolInput {
+    constructor(content) {
+        super();
+        this.content = content;
+    }
+}
+exports.ToolContentInput = ToolContentInput;
+class ToolStreamInput extends ToolInput {
+    constructor(stream) {
+        super();
+        this.stream = stream;
+    }
+}
+exports.ToolStreamInput = ToolStreamInput;
+class ToolCallOutput {
+}
+exports.ToolCallOutput = ToolCallOutput;
+class ToolContentOutput extends ToolCallOutput {
+    constructor(content) {
+        super();
+        this.content = content;
+    }
+}
+exports.ToolContentOutput = ToolContentOutput;
+class ToolStreamOutput extends ToolCallOutput {
+    constructor(stream, { inputClosed } = {}) {
+        super();
+        this.stream = stream;
+        this.inputClosed = inputClosed;
+    }
+}
+exports.ToolStreamOutput = ToolStreamOutput;
+class BaseTool {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, defs }) {
         this.name = name;
         this.description = description;
         this.title = title;
-        if (inputSpec !== undefined && inputSchema !== undefined) {
-            this.inputSpec = new tool_content_type_1.ToolContentSpec({
-                types: [...inputSpec.types],
-                stream: inputSpec.stream,
-                schema: inputSchema,
-            });
+        this.inputSchema = inputSchema;
+        this.inputSpec = inputSpec;
+        this.outputSpec = outputSpec;
+        this.outputSchema = outputSchema;
+        this.defs = defs;
+    }
+}
+exports.BaseTool = BaseTool;
+class FunctionTool extends BaseTool {
+    async *executeStream(context, arguments_) {
+        yield await this.execute(context, arguments_);
+    }
+}
+exports.FunctionTool = FunctionTool;
+class ContentTool extends BaseTool {
+}
+exports.ContentTool = ContentTool;
+class Tool extends BaseTool {
+    constructor(params) {
+        const inputSpec = params.inputSpec !== undefined && params.inputSchema !== undefined
+            ? new tool_content_type_1.ToolContentSpec({ types: [...params.inputSpec.types], stream: params.inputSpec.stream, schema: params.inputSchema })
+            : params.inputSpec;
+        const outputSpec = params.outputSpec !== undefined && params.outputSchema !== undefined
+            ? new tool_content_type_1.ToolContentSpec({ types: [...params.outputSpec.types], stream: params.outputSpec.stream, schema: params.outputSchema })
+            : params.outputSpec;
+        super({
+            name: params.name,
+            description: params.description,
+            title: params.title,
+            inputSchema: params.inputSchema,
+            inputSpec: inputSpec ?? (params.inputSchema !== undefined
+                ? new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: params.inputSchema })
+                : undefined),
+            outputSpec: outputSpec ?? (params.outputSchema !== undefined
+                ? new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: params.outputSchema })
+                : undefined),
+            outputSchema: params.outputSchema,
+            defs: params.defs,
+        });
+    }
+}
+exports.Tool = Tool;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function contentType(content) {
+    if (content instanceof response_1.BinaryContent)
+        return "binary";
+    if (content instanceof response_1.JsonContent)
+        return "json";
+    if (content instanceof response_1.TextContent)
+        return "text";
+    if (content instanceof response_1.FileContent)
+        return "file";
+    if (content instanceof response_1.LinkContent)
+        return "link";
+    if (content instanceof response_1.EmptyContent)
+        return "empty";
+    return undefined;
+}
+function schemaValue(content) {
+    if (content instanceof response_1.BinaryContent)
+        return content.headers;
+    if (content instanceof response_1.JsonContent)
+        return content.json;
+    if (content instanceof response_1.TextContent)
+        return content.text;
+    if (content instanceof response_1.EmptyContent)
+        return null;
+    if (content instanceof response_1.LinkContent)
+        return { name: content.name, url: content.url };
+    if (content instanceof response_1.FileContent)
+        return { name: content.name, mime_type: content.mimeType, size: content.data.length };
+    if (content instanceof response_1.ControlContent)
+        return { method: content.method };
+    if (content instanceof response_1.ErrorContent)
+        return content.code === undefined ? { text: content.text } : { text: content.text, code: content.code };
+    const [header] = (0, utils_1.unpackMessage)(content.pack());
+    return header;
+}
+function schemaWithDefs(schema, defs) {
+    if (schema === undefined)
+        return undefined;
+    if (defs === undefined)
+        return { ...schema };
+    const merged = { ...schema };
+    const existingDefs = merged["$defs"];
+    merged["$defs"] = isRecord(existingDefs) ? { ...defs, ...existingDefs } : { ...defs };
+    return merged;
+}
+function validateJsonSchemaValue(schema, value, root = schema) {
+    if (typeof schema["$ref"] === "string") {
+        const ref = schema["$ref"];
+        if (ref.startsWith("#/$defs/")) {
+            const name = ref.slice("#/$defs/".length);
+            const defs = root["$defs"];
+            if (isRecord(defs) && isRecord(defs[name])) {
+                return validateJsonSchemaValue(defs[name], value, root);
+            }
         }
-        else if (inputSpec !== undefined) {
-            this.inputSpec = inputSpec;
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((item) => JSON.stringify(item) === JSON.stringify(value))) {
+        return "value is not one of the allowed enum values";
+    }
+    if ("const" in schema && JSON.stringify(schema.const) !== JSON.stringify(value)) {
+        return "value does not match const";
+    }
+    const rawType = schema.type;
+    const types = Array.isArray(rawType) ? rawType : rawType === undefined ? [] : [rawType];
+    const matchesType = (type) => {
+        switch (type) {
+            case "object": return isRecord(value);
+            case "array": return Array.isArray(value);
+            case "string": return typeof value === "string";
+            case "number": return typeof value === "number" && Number.isFinite(value);
+            case "integer": return typeof value === "number" && Number.isInteger(value);
+            case "boolean": return typeof value === "boolean";
+            case "null": return value === null;
+            default: return true;
         }
-        else if (inputSchema !== undefined) {
-            this.inputSpec = new tool_content_type_1.ToolContentSpec({
-                types: ["json"],
-                stream: false,
-                schema: inputSchema,
-            });
+    };
+    if (types.length > 0 && !types.some(matchesType)) {
+        return `expected type ${types.join(" or ")}`;
+    }
+    if (isRecord(value)) {
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (typeof key === "string" && !(key in value)) {
+                return `missing required property ${key}`;
+            }
         }
-        if (outputSpec !== undefined && outputSchema !== undefined) {
-            this.outputSpec = new tool_content_type_1.ToolContentSpec({
-                types: [...outputSpec.types],
-                stream: outputSpec.stream,
-                schema: outputSchema,
-            });
+        const properties = isRecord(schema.properties) ? schema.properties : {};
+        for (const [key, propertySchema] of Object.entries(properties)) {
+            if (key in value && isRecord(propertySchema)) {
+                const error = validateJsonSchemaValue(propertySchema, value[key], root);
+                if (error !== undefined)
+                    return `${key}: ${error}`;
+            }
         }
-        else if (outputSpec !== undefined) {
-            this.outputSpec = outputSpec;
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(value)) {
+                if (!(key in properties))
+                    return `unexpected property ${key}`;
+            }
         }
-        else if (outputSchema !== undefined) {
-            this.outputSpec = new tool_content_type_1.ToolContentSpec({
-                types: ["json"],
-                stream: false,
-                schema: outputSchema,
-            });
+    }
+    if (Array.isArray(value) && isRecord(schema.items)) {
+        for (let index = 0; index < value.length; index += 1) {
+            const error = validateJsonSchemaValue(schema.items, value[index], root);
+            if (error !== undefined)
+                return `${index}: ${error}`;
         }
     }
-    get inputSchema() {
-        return this.inputSpec?.schema;
+    if (typeof value === "string") {
+        if (typeof schema.minLength === "number" && value.length < schema.minLength)
+            return `string is shorter than ${schema.minLength}`;
+        if (typeof schema.maxLength === "number" && value.length > schema.maxLength)
+            return `string is longer than ${schema.maxLength}`;
     }
-    get outputSchema() {
-        return this.outputSpec?.schema;
+    if (typeof value === "number") {
+        if (typeof schema.minimum === "number" && value < schema.minimum)
+            return `number is less than ${schema.minimum}`;
+        if (typeof schema.maximum === "number" && value > schema.maximum)
+            return `number is greater than ${schema.maximum}`;
     }
+    return undefined;
 }
-exports.Tool = Tool;
 class Toolkit {
-    constructor({ name, title = name, description = "", tools, rules = [] }) {
+    constructor({ name, title = name, description = "", tools, rules = [], validationMode = "full" }) {
         this.name = name;
         this.title = title;
         this.description = description;
         this.tools = tools;
         this.rules = rules;
+        this.validationMode = validationMode;
     }
     getTool(name) {
         const tool = this.tools.find((t) => t.name === name);
@@ -76,14 +259,117 @@ class Toolkit {
             json[tool.name] = {
                 description: tool.description,
                 title: tool.title,
-                input_spec: tool.inputSpec?.toJson(),
-                output_spec: tool.outputSpec?.toJson(),
+                input_spec: this.resolveInputSpec(tool)?.toJson(),
+                output_spec: this.resolveOutputSpec(tool)?.toJson(),
+                defs: tool.defs,
             };
         }
         return json;
     }
-    async execute(name, args) {
-        return this.getTool(name).execute(args);
+    async execute(first, second, third) {
+        if (typeof first === "string") {
+            const output = await this.executeTool(new ToolContext(), first, new ToolContentInput(new response_1.JsonContent({ json: second })));
+            if (output instanceof ToolContentOutput) {
+                return output.content;
+            }
+            throw new Error(`tool ${first} returned streamed output`);
+        }
+        if (typeof second !== "string" || third === undefined) {
+            throw new Error("toolkit execute requires a tool name and input");
+        }
+        return await this.executeTool(first, second, third);
+    }
+    async executeTool(context, name, input) {
+        const tool = this.getTool(name);
+        if (tool instanceof ContentTool) {
+            return await tool.execute(context, input);
+        }
+        if (!(input instanceof ToolContentInput)) {
+            throw new Error(`tool ${name} does not accept streamed input`);
+        }
+        const args = this.decodeFunctionToolArguments(name, input.content);
+        if (tool instanceof FunctionTool) {
+            return new ToolContentOutput(await tool.execute(context, args));
+        }
+        if (tool instanceof Tool) {
+            return new ToolContentOutput(await tool.execute(args));
+        }
+        throw new Error(`tool ${name} has unsupported type`);
+    }
+    decodeFunctionToolArguments(toolName, input) {
+        if (input instanceof response_1.EmptyContent)
+            return {};
+        if (input instanceof response_1.JsonContent) {
+            if (!isRecord(input.json)) {
+                throw new Error(`tool ${toolName} requires JSON object input`);
+            }
+            return input.json;
+        }
+        throw new Error(`tool ${toolName} requires JSON object input`);
+    }
+    get shouldValidateContentTypes() {
+        return this.validationMode === "full" || this.validationMode === "contentTypes";
+    }
+    get shouldValidateSchema() {
+        return this.validationMode === "full";
+    }
+    resolveInputSpec(tool) {
+        if (tool instanceof ContentTool)
+            return tool.inputSpec;
+        if (tool.inputSpec !== undefined)
+            return tool.inputSpec;
+        return new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: tool.inputSchema ?? { type: "object", additionalProperties: true } });
+    }
+    resolveOutputSpec(tool) {
+        if (tool.outputSpec !== undefined) {
+            if (tool.outputSchema !== undefined && tool.outputSpec.schema === undefined && tool.outputSpec.types.includes("json")) {
+                return new tool_content_type_1.ToolContentSpec({ types: [...tool.outputSpec.types], stream: tool.outputSpec.stream, schema: tool.outputSchema });
+            }
+            return tool.outputSpec;
+        }
+        if (tool.outputSchema === undefined)
+            return undefined;
+        return new tool_content_type_1.ToolContentSpec({ types: ["json"], stream: false, schema: tool.outputSchema });
+    }
+    validateStreamMode({ tool, direction, spec, stream }) {
+        if (!this.shouldValidateContentTypes || spec === undefined)
+            return;
+        if (spec.stream !== stream) {
+            const expected = spec.stream ? "streamed" : "single-content";
+            const actual = stream ? "streamed" : "single-content";
+            throw new InvalidToolDataException(`tool ${tool.name} ${direction} is ${actual} but ${direction}_spec requires ${expected} ${direction}`);
+        }
+    }
+    validateContentType({ tool, direction, spec, content }) {
+        if (!this.shouldValidateContentTypes || spec === undefined)
+            return;
+        const type = contentType(content);
+        if (type === undefined || !spec.types.includes(type)) {
+            const allowed = spec.types.join(", ");
+            const actual = type ?? content.constructor.name;
+            throw new InvalidToolDataException(`tool ${tool.name} ${direction} content type ${actual} is not allowed by ${direction}_spec (${allowed})`);
+        }
+    }
+    validateSchema({ tool, direction, content, schema }) {
+        if (!this.shouldValidateSchema)
+            return;
+        const resolved = schemaWithDefs(schema, tool.defs);
+        if (resolved === undefined)
+            return;
+        const error = validateJsonSchemaValue(resolved, schemaValue(content), resolved);
+        if (error !== undefined) {
+            throw new InvalidToolDataException(`tool ${tool.name} ${direction} does not match ${direction}_schema: ${error}`);
+        }
+    }
+    validateInputContent(tool, content) {
+        const spec = this.resolveInputSpec(tool);
+        this.validateContentType({ tool, direction: "input", spec, content });
+        this.validateSchema({ tool, direction: "input", content, schema: spec?.schema });
+    }
+    validateOutputContent(tool, content) {
+        const spec = this.resolveOutputSpec(tool);
+        this.validateContentType({ tool, direction: "output", spec, content });
+        this.validateSchema({ tool, direction: "output", content, schema: spec?.schema });
     }
 }
 exports.Toolkit = Toolkit;
@@ -100,19 +386,24 @@ exports.HostedToolkit = HostedToolkit;
 class _RemoteToolkitWrapper {
     constructor({ toolkit, room }) {
         this._toolCallHandler = this._toolCall.bind(this);
+        this._toolCallRequestChunkHandler = this._toolCallRequestChunk.bind(this);
         this._roomEventHandler = this._onRoomEvent.bind(this);
         this._started = false;
         this._public = false;
         this._registerTask = null;
+        this._requestStreams = new Map();
+        this._requestStreamTools = new Map();
+        this._pendingRequestChunks = new Map();
         this.toolkit = toolkit;
         this.client = room;
     }
     async start({ public_: isPublic = false } = {}) {
         if (this._started) {
-            throw new room_server_client_1.RoomServerException(`toolkit '${this.toolkit.name}' is already started`);
+            throw new room_server_client_1.RoomServerException(`toolkit ${this.toolkit.name} is already started`);
         }
         this._public = isPublic;
         this.client.protocol.addHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+        this.client.protocol.addHandler(`room.tool_call_request_chunk.${this.toolkit.name}`, this._toolCallRequestChunkHandler);
         this.client.on("disconnected", this._roomEventHandler);
         this.client.on("reconnected", this._roomEventHandler);
         try {
@@ -123,6 +414,7 @@ class _RemoteToolkitWrapper {
             this.client.off("disconnected", this._roomEventHandler);
             this.client.off("reconnected", this._roomEventHandler);
             this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+            this.client.protocol.removeHandler(`room.tool_call_request_chunk.${this.toolkit.name}`, this._toolCallRequestChunkHandler);
             throw error;
         }
     }
@@ -133,11 +425,13 @@ class _RemoteToolkitWrapper {
         this._started = false;
         this.client.off("disconnected", this._roomEventHandler);
         this.client.off("reconnected", this._roomEventHandler);
+        this._failActiveRequestStreams(new room_server_client_1.RoomServerException("hosted toolkit stopped"));
         try {
             await this._unregister();
         }
         finally {
             this.client.protocol.removeHandler(`room.tool_call.${this.toolkit.name}`, this._toolCallHandler);
+            this.client.protocol.removeHandler(`room.tool_call_request_chunk.${this.toolkit.name}`, this._toolCallRequestChunkHandler);
         }
     }
     async _register(public_) {
@@ -148,8 +442,7 @@ class _RemoteToolkitWrapper {
             tools: this.toolkit.getTools(),
             public: public_,
         });
-        const json = response.json;
-        this._registrationId = json["id"];
+        this._registrationId = response.json["id"];
     }
     async _unregister() {
         const registrationId = this._registrationId;
@@ -161,6 +454,23 @@ class _RemoteToolkitWrapper {
             id: registrationId,
         });
     }
+    _failActiveRequestStreams(error) {
+        const streams = [...this._requestStreams.values()];
+        this._requestStreams.clear();
+        this._requestStreamTools.clear();
+        this._pendingRequestChunks.clear();
+        for (const stream of streams) {
+            stream.add({ error });
+            stream.close();
+        }
+    }
+    _closeRequestStream(toolCallId) {
+        this._pendingRequestChunks.delete(toolCallId);
+        this._requestStreamTools.delete(toolCallId);
+        const stream = this._requestStreams.get(toolCallId);
+        this._requestStreams.delete(toolCallId);
+        stream?.close();
+    }
     _scheduleRegisterIfNeeded() {
         if (!this._started || this._registrationId != null || this._registerTask != null || this.client.isClosed) {
             return;
@@ -179,46 +489,201 @@ class _RemoteToolkitWrapper {
         }
         if (event.status === "disconnected") {
             this._registrationId = undefined;
+            const message = event.message?.trim();
+            this._failActiveRequestStreams(new room_server_client_1.RoomServerException(message == null || message.length === 0
+                ? "room connection lost before streamed tool call request completed"
+                : `room connection lost before streamed tool call request completed: ${message}`));
             return;
         }
         if (event.status === "reconnected") {
             this._scheduleRegisterIfNeeded();
         }
     }
-    async _toolCall(protocol, messageId, type, data) {
+    _resolveParticipant(participantId) {
+        if (typeof participantId !== "string" || participantId.length === 0)
+            return undefined;
+        const local = this.client.localParticipant;
+        if (local != null && local.id === participantId)
+            return local;
+        for (const remote of this.client.messaging.remoteParticipants) {
+            if (remote.id === participantId)
+                return remote;
+        }
+        return new participant_1.RemoteParticipant(this.client, participantId, "user");
+    }
+    _contentFromToolCallArguments(rawArguments, payload) {
+        if (!isRecord(rawArguments)) {
+            throw new Error("arguments must be a content header object");
+        }
+        if (typeof rawArguments.type === "string") {
+            return (0, response_1.unpackContent)((0, utils_1.packMessage)(rawArguments, payload.length > 0 ? payload : undefined));
+        }
+        return new response_1.JsonContent({ json: rawArguments });
+    }
+    async _sendToolCallResponse(messageId, chunk) {
+        try {
+            await this.client.protocol.send("room.tool_call_response", chunk.pack(), { id: messageId });
+            return true;
+        }
+        catch (error) {
+            console.debug("unable to send tool call response", error);
+            return false;
+        }
+    }
+    async _sendToolCallResponseChunk(messageId, toolCallId, chunk) {
+        const [header, payload] = (0, utils_1.unpackMessage)(chunk.pack());
+        try {
+            await this.client.protocol.send("room.tool_call_response_chunk", (0, utils_1.packMessage)({ tool_call_id: toolCallId, chunk: header }, payload.length > 0 ? payload : undefined), { id: messageId });
+            return true;
+        }
+        catch (error) {
+            console.debug("unable to send tool call response chunk", error);
+            return false;
+        }
+    }
+    _streamFromController(controller) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                for await (const item of controller.stream) {
+                    if ("error" in item)
+                        throw item.error;
+                    yield item.content;
+                }
+            },
+        };
+    }
+    _enqueueRequestStreamChunk(stream, chunk, tool) {
+        if (chunk instanceof response_1.ControlContent) {
+            if (chunk.method === "open")
+                return;
+            if (chunk.method === "close") {
+                stream.close();
+                return;
+            }
+            return;
+        }
+        if (tool !== undefined) {
+            try {
+                this.toolkit.validateInputContent(tool, chunk);
+            }
+            catch (error) {
+                stream.add({ error });
+                stream.close();
+                return;
+            }
+        }
+        stream.add({ content: chunk });
+    }
+    async _toolCall(protocol, messageId, _type, data) {
         if (!this.client.isActiveProtocol(protocol)) {
             return;
         }
+        const toolCallIdFallback = `${messageId}`;
+        let toolCallId = toolCallIdFallback;
+        let openedResponseStream = false;
         try {
-            const [message, _] = (0, utils_1.unpackMessage)(data);
+            const [message, payload] = (0, utils_1.unpackMessage)(data);
             const toolName = message["name"];
-            const rawArguments = message["arguments"];
-            let args;
-            if (rawArguments &&
-                typeof rawArguments === "object" &&
-                !Array.isArray(rawArguments) &&
-                "type" in rawArguments) {
-                const content = rawArguments;
-                const contentType = content["type"];
-                if (contentType === "json") {
-                    args = content["json"] ?? {};
-                }
-                else if (contentType === "empty") {
-                    args = {};
-                }
-                else {
-                    throw new Error(`tool '${toolName}' requires JSON object input, received content type '${String(contentType)}'`);
+            if (typeof toolName !== "string" || toolName.length === 0) {
+                throw new Error("tool call requires a tool name");
+            }
+            toolCallId = typeof message["tool_call_id"] === "string" && message["tool_call_id"].length > 0
+                ? message["tool_call_id"]
+                : toolCallIdFallback;
+            const inputChunk = this._contentFromToolCallArguments(message["arguments"], payload);
+            const requestStream = inputChunk instanceof response_1.ControlContent && inputChunk.method === "open";
+            if (inputChunk instanceof response_1.ControlContent && !requestStream) {
+                await this._sendToolCallResponse(messageId, new response_1.ErrorContent({ text: "request stream must start with an open control chunk" }));
+                return;
+            }
+            const tool = this.toolkit.getTool(toolName);
+            this.toolkit.validateStreamMode({ tool, direction: "input", spec: this.toolkit.resolveInputSpec(tool), stream: requestStream });
+            let resolvedInput;
+            if (requestStream) {
+                const controller = new stream_controller_1.StreamController();
+                this._requestStreams.set(toolCallId, controller);
+                this._requestStreamTools.set(toolCallId, tool);
+                this._enqueueRequestStreamChunk(controller, new response_1.ControlContent({ method: "open" }), tool);
+                const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];
+                this._pendingRequestChunks.delete(toolCallId);
+                for (const chunk of buffered) {
+                    this._enqueueRequestStreamChunk(controller, chunk, tool);
                 }
+                resolvedInput = new ToolStreamInput(this._streamFromController(controller));
             }
             else {
-                args = rawArguments ?? {};
+                this.toolkit.validateInputContent(tool, inputChunk);
+                resolvedInput = new ToolContentInput(inputChunk);
+            }
+            const context = new RoomToolContext({
+                room: this.client,
+                caller: this._resolveParticipant(message["caller_id"]),
+                onBehalfOf: this._resolveParticipant(message["on_behalf_of_id"]),
+            });
+            const output = await this.toolkit.execute(context, toolName, resolvedInput);
+            if (output instanceof ToolContentOutput) {
+                this.toolkit.validateStreamMode({ tool, direction: "output", spec: this.toolkit.resolveOutputSpec(tool), stream: false });
+                this.toolkit.validateOutputContent(tool, output.content);
+                await this._sendToolCallResponse(messageId, output.content);
+                return;
+            }
+            if (output instanceof ToolStreamOutput) {
+                this.toolkit.validateStreamMode({ tool, direction: "output", spec: this.toolkit.resolveOutputSpec(tool), stream: true });
+                openedResponseStream = true;
+                if (!await this._sendToolCallResponse(messageId, new response_1.ControlContent({ method: "open" })))
+                    return;
+                for await (const chunk of output.stream) {
+                    this.toolkit.validateOutputContent(tool, chunk);
+                    if (!await this._sendToolCallResponseChunk(messageId, toolCallId, chunk))
+                        return;
+                }
+                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ControlContent({ method: "close" }));
+                return;
+            }
+            throw new Error(`tool ${toolName} returned unsupported output`);
+        }
+        catch (error) {
+            if (!openedResponseStream) {
+                await this._sendToolCallResponse(messageId, new response_1.ErrorContent({ text: String(error) }));
+                return;
             }
-            const response = await this.toolkit.execute(toolName, args);
-            await this.client.protocol.send("room.tool_call_response", response.pack(), { id: messageId });
+            if (!(error instanceof InvalidToolDataException)) {
+                await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ErrorContent({ text: String(error) }));
+            }
+            await this._sendToolCallResponseChunk(messageId, toolCallId, new response_1.ControlContent({
+                method: "close",
+                statusCode: error instanceof InvalidToolDataException ? response_1.ControlCloseStatus.INVALID_DATA : undefined,
+                message: error instanceof InvalidToolDataException ? error.message : undefined,
+            }));
+        }
+        finally {
+            this._closeRequestStream(toolCallId);
         }
-        catch (e) {
-            const err = new response_1.ErrorContent({ text: String(e) });
-            await this.client.protocol.send("room.tool_call_response", err.pack(), { id: messageId });
+    }
+    async _toolCallRequestChunk(protocol, _messageId, _type, data) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
+        try {
+            const [message, payload] = (0, utils_1.unpackMessage)(data);
+            const toolCallId = message["tool_call_id"];
+            if (typeof toolCallId !== "string" || toolCallId.length === 0)
+                return;
+            const chunkHeader = message["chunk"];
+            if (!isRecord(chunkHeader))
+                return;
+            const chunk = (0, response_1.unpackContent)((0, utils_1.packMessage)(chunkHeader, payload.length > 0 ? payload : undefined));
+            const stream = this._requestStreams.get(toolCallId);
+            if (stream === undefined) {
+                const buffered = this._pendingRequestChunks.get(toolCallId) ?? [];
+                buffered.push(chunk);
+                this._pendingRequestChunks.set(toolCallId, buffered);
+                return;
+            }
+            this._enqueueRequestStreamChunk(stream, chunk, this._requestStreamTools.get(toolCallId));
+        }
+        catch (error) {
+            console.warn("ignoring malformed request stream chunk", error);
         }
     }
 }