@meshagent/meshagent 0.41.4 → 0.41.5

package/CHANGELOG.md

@@ -1,3 +1,6 @@
+## [0.41.5]
+- Stability
+
 ## [0.41.4]
 - Stability
 

package/dist/browser/agent-client.d.ts

@@ -1,5 +1,6 @@
 import { RoomClient } from "./room-client";
 import type { Content } from "./response";
+import { ToolInput, type ToolCallOutput } from "./agent";
 import { ToolContentSpec } from "./tool-content-type";
 export declare class ToolDescription {
     title: string;
@@ -56,9 +57,18 @@ export declare class AgentsClient {
         participantName?: string;
         timeout?: number;
     }): Promise<ToolkitDescription[]>;
+    invokeTool(params: {
+        toolkit: string;
+        tool: string;
+        input: ToolInput;
+        participantId?: string;
+        onBehalfOfId?: string;
+    }): Promise<ToolCallOutput>;
     invokeTool(params: {
         toolkit: string;
         tool: string;
         arguments: Record<string, any>;
+        participantId?: string;
+        onBehalfOfId?: string;
     }): Promise<Content>;
 }

package/dist/browser/agent-client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentsClient = exports.ToolkitDescription = exports.ToolDescription = void 0;
+const agent_1 = require("./agent");
 const tool_content_type_1 = require("./tool-content-type");
 class ToolDescription {
     constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, defs }) {
@@ -139,7 +140,41 @@ class AgentsClient {
         return await this.client.listToolkits(params);
     }
     async invokeTool(params) {
-        return await this.client.invoke(params);
+        if (params.input === undefined) {
+            return await this.client.invoke({
+                toolkit: params.toolkit,
+                tool: params.tool,
+                arguments: params.arguments ?? {},
+                participantId: params.participantId,
+                onBehalfOfId: params.onBehalfOfId,
+            });
+        }
+        if (params.input instanceof agent_1.ToolContentInput) {
+            const output = await this.client.invokeToolCall({
+                toolkit: params.toolkit,
+                tool: params.tool,
+                input: params.input.content,
+                participantId: params.participantId,
+                onBehalfOfId: params.onBehalfOfId,
+            });
+            return output.kind === "content"
+                ? new agent_1.ToolContentOutput(output.content)
+                : new agent_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
+        }
+        if (params.input instanceof agent_1.ToolStreamInput) {
+            const output = await this.client.invokeToolCall({
+                toolkit: params.toolkit,
+                tool: params.tool,
+                input: params.input.stream,
+                streamInput: true,
+                participantId: params.participantId,
+                onBehalfOfId: params.onBehalfOfId,
+            });
+            return output.kind === "content"
+                ? new agent_1.ToolContentOutput(output.content)
+                : new agent_1.ToolStreamOutput(output.stream, { inputClosed: output.inputClosed });
+        }
+        throw new Error("invokeTool input must be ToolContentInput or ToolStreamInput");
     }
 }
 exports.AgentsClient = AgentsClient;

package/dist/browser/agent.d.ts

@@ -1,42 +1,137 @@
 import { RoomClient } from "./room-client";
 import { RequiredToolkit } from "./requirement";
 import { type Content } from "./response";
+import { RoomServerException } from "./room-server-client";
 import { ToolContentSpec } from "./tool-content-type";
-export declare abstract class Tool {
+import { Participant } from "./participant";
+export type ValidationMode = "full" | "contentTypes" | "none";
+export declare class InvalidToolDataException extends RoomServerException {
+    constructor(message: string);
+}
+export declare class ToolContext {
+    readonly caller?: Participant;
+    readonly onBehalfOf?: Participant;
+    constructor({ caller, onBehalfOf }?: {
+        caller?: Participant;
+        onBehalfOf?: Participant;
+    });
+}
+export declare class RoomToolContext extends ToolContext {
+    readonly room: RoomClient;
+    constructor({ room, caller, onBehalfOf }: {
+        room: RoomClient;
+        caller?: Participant;
+        onBehalfOf?: Participant;
+    });
+}
+export declare abstract class ToolInput {
+}
+export declare class ToolContentInput extends ToolInput {
+    readonly content: Content;
+    constructor(content: Content);
+}
+export declare class ToolStreamInput extends ToolInput {
+    readonly stream: AsyncIterable<Content>;
+    constructor(stream: AsyncIterable<Content>);
+}
+export declare abstract class ToolCallOutput {
+}
+export declare class ToolContentOutput extends ToolCallOutput {
+    readonly content: Content;
+    constructor(content: Content);
+}
+export declare class ToolStreamOutput extends ToolCallOutput {
+    readonly stream: AsyncIterable<Content>;
+    readonly inputClosed?: Promise<void>;
+    constructor(stream: AsyncIterable<Content>, { inputClosed }?: {
+        inputClosed?: Promise<void>;
+    });
+}
+export declare abstract class BaseTool {
     readonly name: string;
-    readonly description: string;
-    readonly title: string;
+    readonly description?: string;
+    readonly title?: string;
+    readonly inputSchema?: Record<string, any>;
     readonly inputSpec?: ToolContentSpec;
     readonly outputSpec?: ToolContentSpec;
-    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema }: {
+    readonly outputSchema?: Record<string, any>;
+    readonly defs?: Record<string, any>;
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, defs }: {
         name: string;
-        description: string;
-        title: string;
+        description?: string;
+        title?: string;
+        inputSchema?: Record<string, any>;
+        inputSpec?: ToolContentSpec;
+        outputSpec?: ToolContentSpec;
+        outputSchema?: Record<string, any>;
+        defs?: Record<string, any>;
+    });
+}
+export declare abstract class FunctionTool extends BaseTool {
+    abstract execute(context: ToolContext, arguments_: Record<string, any>): Promise<Content>;
+    executeStream(context: ToolContext, arguments_: Record<string, any>): AsyncIterable<Content>;
+}
+export declare abstract class ContentTool extends BaseTool {
+    abstract execute(context: ToolContext, input: ToolInput): Promise<ToolCallOutput>;
+}
+export declare abstract class Tool extends BaseTool {
+    constructor(params: {
+        name: string;
+        description?: string;
+        title?: string;
         inputSchema?: Record<string, any>;
         inputSpec?: ToolContentSpec;
         outputSpec?: ToolContentSpec;
         outputSchema?: Record<string, any>;
+        defs?: Record<string, any>;
     });
-    get inputSchema(): Record<string, any> | undefined;
-    get outputSchema(): Record<string, any> | undefined;
     abstract execute(arguments_: Record<string, any>): Promise<Content>;
 }
 export declare class Toolkit {
     readonly name: string;
-    readonly title: string;
-    readonly description: string;
-    readonly tools: Tool[];
+    readonly title?: string;
+    readonly description?: string;
+    readonly tools: BaseTool[];
     readonly rules: string[];
-    constructor({ name, title, description, tools, rules }: {
+    readonly validationMode: ValidationMode;
+    constructor({ name, title, description, tools, rules, validationMode }: {
         name: string;
         title?: string;
         description?: string;
-        tools: Tool[];
+        tools: BaseTool[];
         rules?: string[];
+        validationMode?: ValidationMode;
     });
-    getTool(name: string): Tool;
+    getTool(name: string): BaseTool;
     getTools(): Record<string, any>;
     execute(name: string, args: Record<string, any>): Promise<Content>;
+    execute(context: ToolContext, name: string, input: ToolInput): Promise<ToolCallOutput>;
+    private executeTool;
+    private decodeFunctionToolArguments;
+    private get shouldValidateContentTypes();
+    private get shouldValidateSchema();
+    resolveInputSpec(tool: BaseTool): ToolContentSpec | undefined;
+    resolveOutputSpec(tool: BaseTool): ToolContentSpec | undefined;
+    validateStreamMode({ tool, direction, spec, stream }: {
+        tool: BaseTool;
+        direction: "input" | "output";
+        spec?: ToolContentSpec;
+        stream: boolean;
+    }): void;
+    validateContentType({ tool, direction, spec, content }: {
+        tool: BaseTool;
+        direction: "input" | "output";
+        spec?: ToolContentSpec;
+        content: Content;
+    }): void;
+    validateSchema({ tool, direction, content, schema }: {
+        tool: BaseTool;
+        direction: "input" | "output";
+        content: Content;
+        schema?: Record<string, any>;
+    }): void;
+    validateInputContent(tool: BaseTool, content: Content): void;
+    validateOutputContent(tool: BaseTool, content: Content): void;
 }
 export declare class HostedToolkit {
     readonly toolkit: Toolkit;