@meshagent/meshagent 0.41.4 → 0.41.6

package/dist/esm/toolkit-config.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIConnectors = exports.Connector = exports.MCPServer = exports.MCPHeader = void 0;
+exports.mcpConnectorsFromRoomServices = mcpConnectorsFromRoomServices;
+class MCPHeader {
+    constructor({ name, value }) {
+        this.name = name;
+        this.value = value;
+    }
+    static fromJson(json) {
+        return new MCPHeader({
+            name: String(json["name"]),
+            value: String(json["value"]),
+        });
+    }
+    toJson() {
+        return {
+            name: this.name,
+            value: this.value,
+        };
+    }
+}
+exports.MCPHeader = MCPHeader;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMcpHeaders(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => {
+            if (!isRecord(entry)) {
+                throw new Error("MCPServer.headers entries must be JSON objects");
+            }
+            return MCPHeader.fromJson(entry);
+        });
+    }
+    if (isRecord(value)) {
+        return Object.entries(value).map(([name, headerValue]) => new MCPHeader({
+            name,
+            value: String(headerValue),
+        }));
+    }
+    throw new Error("MCPServer.headers must be a header list or object");
+}
+class MCPServer {
+    constructor({ serverLabel, authorization, serverUrl, allowedTools, headers, requireApproval, alwaysRequireApproval, neverRequireApproval, openaiConnectorId, }) {
+        this.serverLabel = serverLabel;
+        this.authorization = authorization ?? undefined;
+        this.serverUrl = serverUrl ?? undefined;
+        this.allowedTools = allowedTools ?? undefined;
+        this.headers = headers ?? undefined;
+        this.requireApproval = requireApproval ?? undefined;
+        this.alwaysRequireApproval = alwaysRequireApproval ?? undefined;
+        this.neverRequireApproval = neverRequireApproval ?? undefined;
+        this.openaiConnectorId = openaiConnectorId ?? undefined;
+    }
+    static fromJson(json) {
+        const serverLabel = json["server_label"];
+        if (typeof serverLabel !== "string") {
+            throw new Error("MCPServer requires server_label");
+        }
+        const requireApproval = json["require_approval"];
+        if (requireApproval != null && requireApproval !== "always" && requireApproval !== "never") {
+            throw new Error("MCPServer.require_approval must be always or never");
+        }
+        return new MCPServer({
+            serverLabel,
+            authorization: typeof json["authorization"] === "string" ? json["authorization"] : undefined,
+            serverUrl: typeof json["server_url"] === "string" ? json["server_url"] : undefined,
+            allowedTools: Array.isArray(json["allowed_tools"])
+                ? json["allowed_tools"].map(String)
+                : undefined,
+            headers: parseMcpHeaders(json["headers"]),
+            requireApproval,
+            alwaysRequireApproval: Array.isArray(json["always_require_approval"])
+                ? json["always_require_approval"].map(String)
+                : undefined,
+            neverRequireApproval: Array.isArray(json["never_require_approval"])
+                ? json["never_require_approval"].map(String)
+                : undefined,
+            openaiConnectorId: typeof json["openai_connector_id"] === "string"
+                ? json["openai_connector_id"]
+                : (typeof json["openaiConnectorId"] === "string" ? json["openaiConnectorId"] : undefined),
+        });
+    }
+    static fromJsonString(data) {
+        const parsed = JSON.parse(data);
+        if (!isRecord(parsed)) {
+            throw new Error("MCPServer JSON must be an object");
+        }
+        return MCPServer.fromJson(parsed);
+    }
+    toJson() {
+        const json = {
+            server_label: this.serverLabel,
+            server_url: this.serverUrl ?? null,
+        };
+        if (this.authorization !== undefined) {
+            json["authorization"] = this.authorization;
+        }
+        if (this.allowedTools !== undefined) {
+            json["allowed_tools"] = this.allowedTools;
+        }
+        if (this.headers !== undefined) {
+            json["headers"] = this.headers.map((header) => header.toJson());
+        }
+        if (this.requireApproval !== undefined) {
+            json["require_approval"] = this.requireApproval;
+        }
+        if (this.alwaysRequireApproval !== undefined) {
+            json["always_require_approval"] = this.alwaysRequireApproval;
+        }
+        if (this.neverRequireApproval !== undefined) {
+            json["never_require_approval"] = this.neverRequireApproval;
+        }
+        if (this.openaiConnectorId !== undefined) {
+            json["openai_connector_id"] = this.openaiConnectorId;
+        }
+        return json;
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    copyWith({ serverLabel, authorization, serverUrl, allowedTools, headers, requireApproval, alwaysRequireApproval, neverRequireApproval, openaiConnectorId, }) {
+        return new MCPServer({
+            serverLabel: serverLabel ?? this.serverLabel,
+            authorization: authorization ?? this.authorization,
+            serverUrl: serverUrl ?? this.serverUrl,
+            allowedTools: allowedTools ?? this.allowedTools,
+            headers: headers ?? this.headers,
+            requireApproval: requireApproval ?? this.requireApproval,
+            alwaysRequireApproval: alwaysRequireApproval ?? this.alwaysRequireApproval,
+            neverRequireApproval: neverRequireApproval ?? this.neverRequireApproval,
+            openaiConnectorId: openaiConnectorId ?? this.openaiConnectorId,
+        });
+    }
+}
+exports.MCPServer = MCPServer;
+class Connector {
+    constructor({ name, server, oauth, }) {
+        this.name = name;
+        this.server = server;
+        this.oauth = oauth ?? undefined;
+    }
+    static oauthClientSecretIdFromHeaders(server) {
+        for (const header of server.headers ?? []) {
+            if (header.name === "Meshagent-OAuth-Client-Secret-Id") {
+                const value = header.value.trim();
+                if (value.length > 0) {
+                    return value;
+                }
+            }
+        }
+        return null;
+    }
+    static buildConnectorRef({ server, oauth, }) {
+        const clientSecretId = Connector.oauthClientSecretIdFromHeaders(server);
+        const serverUrl = server.serverUrl;
+        const hasServerUrl = serverUrl != null && serverUrl.trim().length > 0;
+        const requiresOAuth = oauth != null || server.openaiConnectorId != null || clientSecretId != null;
+        if (!requiresOAuth) {
+            return null;
+        }
+        if (server.openaiConnectorId == null && clientSecretId == null && !hasServerUrl) {
+            return null;
+        }
+        return {
+            openaiConnectorId: server.openaiConnectorId ?? null,
+            serverUrl: hasServerUrl ? serverUrl.trim() : null,
+            clientSecretId,
+        };
+    }
+    buildConnectorRef() {
+        return Connector.buildConnectorRef({ server: this.server, oauth: this.oauth });
+    }
+    async isConnected(room, agentName) {
+        const connector = this.buildConnectorRef();
+        if (connector == null && this.oauth == null) {
+            return true;
+        }
+        const token = await room.secrets.getOfflineOAuthToken({
+            connector,
+            oauth: this.oauth,
+            delegatedTo: agentName,
+        });
+        return token != null;
+    }
+    async authenticate(client, agent, redirectUri) {
+        const connector = this.buildConnectorRef();
+        if (connector == null && this.oauth == null) {
+            return null;
+        }
+        const localParticipant = client.localParticipant;
+        if (localParticipant == null) {
+            throw new Error("Connector.authenticate requires a local participant");
+        }
+        const agentName = agent.getAttribute("name");
+        return await client.secrets.requestOAuthToken({
+            fromParticipantId: localParticipant.id,
+            connector,
+            oauth: this.oauth,
+            redirectUri,
+            delegateTo: agentName == null ? null : String(agentName),
+        });
+    }
+}
+exports.Connector = Connector;
+function headersFromEndpointSpec(headers) {
+    if (headers == null || Object.keys(headers).length === 0) {
+        return undefined;
+    }
+    return Object.entries(headers).map(([name, value]) => new MCPHeader({ name, value }));
+}
+function normalizeEndpointPath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function bracketIpv6Host(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function roomServiceMcpServerUrl({ service, port, endpoint, }) {
+    const endpointPath = normalizeEndpointPath(endpoint.path);
+    const portValue = typeof port.num === "number" ? port.num : null;
+    if (service.external == null) {
+        if (portValue == null) {
+            return `http://localhost${endpointPath}`;
+        }
+        return `http://localhost:${portValue}${endpointPath}`;
+    }
+    const externalUrl = service.external.url;
+    if (externalUrl.length === 0) {
+        return null;
+    }
+    let baseUrl;
+    try {
+        baseUrl = new URL(externalUrl.includes("://") ? externalUrl : `https://${externalUrl}`);
+    }
+    catch {
+        return null;
+    }
+    if (baseUrl.hostname.length === 0) {
+        return null;
+    }
+    const normalizedBasePath = baseUrl.pathname.endsWith("/")
+        ? baseUrl.pathname.slice(0, -1)
+        : baseUrl.pathname;
+    const joinedPath = normalizedBasePath.length === 0 || normalizedBasePath === "/"
+        ? endpointPath
+        : `${normalizedBasePath}${endpointPath}`;
+    if (portValue == null) {
+        baseUrl.pathname = joinedPath;
+        return baseUrl.toString();
+    }
+    const userInfo = baseUrl.username.length > 0
+        ? `${baseUrl.username}${baseUrl.password.length > 0 ? `:${baseUrl.password}` : ""}@`
+        : "";
+    const query = baseUrl.search;
+    const fragment = baseUrl.hash;
+    return `${baseUrl.protocol}//${userInfo}${bracketIpv6Host(baseUrl.hostname)}:${portValue}${joinedPath}${query}${fragment}`;
+}
+function mcpConnectorsFromRoomServices({ services, agentName, }) {
+    const connectors = [];
+    for (const service of services) {
+        const filter = service.metadata.annotations?.["meshagent.agent.filter"];
+        if (filter != null && filter !== agentName) {
+            continue;
+        }
+        for (const port of service.ports ?? []) {
+            for (const endpoint of port.endpoints ?? []) {
+                const mcp = endpoint.mcp;
+                if (mcp == null) {
+                    continue;
+                }
+                connectors.push(new Connector({
+                    name: mcp.label,
+                    server: new MCPServer({
+                        serverLabel: mcp.label,
+                        serverUrl: roomServiceMcpServerUrl({ service, port, endpoint }),
+                        headers: headersFromEndpointSpec(mcp.headers),
+                        requireApproval: mcp.require_approval,
+                        openaiConnectorId: mcp.openai_connector_id,
+                    }),
+                    oauth: mcp.oauth,
+                }));
+            }
+        }
+    }
+    return connectors;
+}
+function getEnvValue(name) {
+    if (typeof process === "undefined") {
+        return "";
+    }
+    return process.env?.[name] ?? "";
+}
+class OpenAIConnectors {
+}
+exports.OpenAIConnectors = OpenAIConnectors;
+OpenAIConnectors.dropbox = new Connector({
+    name: "Dropbox",
+    server: new MCPServer({ serverLabel: "Dropbox", openaiConnectorId: "connector_dropbox" }),
+    oauth: {
+        client_id: getEnvValue("DROPBOX_CONNECTOR_OAUTH_CLIENT_ID"),
+        client_secret: "CLIENT_SECRET",
+        authorization_endpoint: "https://www.dropbox.com/oauth2/authorize",
+        token_endpoint: "https://api.dropbox.com/oauth2/token",
+        no_pkce: true,
+        scopes: ["files.metadata.read", "account_info.read", "files.content.read"],
+    },
+});
+OpenAIConnectors.gmail = new Connector({
+    name: "Gmail",
+    server: new MCPServer({ serverLabel: "Gmail", openaiConnectorId: "connector_gmail" }),
+    oauth: {
+        client_id: getEnvValue("GOOGLE_CONNECTOR_OAUTH_CLIENT_ID"),
+        authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+        token_endpoint: "https://oauth2.googleapis.com/token",
+        no_pkce: false,
+        scopes: [
+            "https://www.googleapis.com/auth/gmail.modify",
+            "https://www.googleapis.com/auth/userinfo.email",
+            "https://www.googleapis.com/auth/userinfo.profile",
+        ],
+    },
+});
+OpenAIConnectors.googleCalendar = new Connector({
+    name: "Google Calendar",
+    server: new MCPServer({ serverLabel: "Google_Calendar", openaiConnectorId: "connector_googlecalendar" }),
+    oauth: {
+        client_id: getEnvValue("GOOGLE_CONNECTOR_OAUTH_CLIENT_ID"),
+        authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+        token_endpoint: "https://oauth2.googleapis.com/token",
+        no_pkce: false,
+        scopes: [
+            "https://www.googleapis.com/auth/userinfo.email",
+            "https://www.googleapis.com/auth/userinfo.profile",
+            "https://www.googleapis.com/auth/calendar.events",
+        ],
+    },
+});
+OpenAIConnectors.googleDrive = new Connector({
+    name: "Google Drive",
+    server: new MCPServer({ serverLabel: "Google_Drive", openaiConnectorId: "connector_googledrive" }),
+    oauth: {
+        client_id: "CLIENT_ID",
+        client_secret: getEnvValue("GOOGLE_CONNECTOR_OAUTH_CLIENT_ID"),
+        authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+        token_endpoint: "https://oauth2.googleapis.com/token",
+        no_pkce: false,
+        scopes: [
+            "https://www.googleapis.com/auth/userinfo.email",
+            "https://www.googleapis.com/auth/userinfo.profile",
+            "https://www.googleapis.com/auth/drive.readonly",
+        ],
+    },
+});
+OpenAIConnectors.microsoftTeams = new Connector({
+    name: "Microsoft Teams",
+    server: new MCPServer({ serverLabel: "Microsoft_Teams", openaiConnectorId: "connector_microsoftteams" }),
+    oauth: {
+        client_id: getEnvValue("MICROSOFT_CONNECTOR_OAUTH_CLIENT_ID"),
+        client_secret: "CLIENT_SECRET",
+        authorization_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        token_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        no_pkce: false,
+        scopes: ["User.Read", "Chat.Read", "ChannelMessage.Read.All"],
+    },
+});
+OpenAIConnectors.outlookCalendar = new Connector({
+    name: "Outlook Calendar",
+    server: new MCPServer({ serverLabel: "Outlook_Calendar", openaiConnectorId: "connector_outlookcalendar" }),
+    oauth: {
+        client_id: getEnvValue("MICROSOFT_CONNECTOR_OAUTH_CLIENT_ID"),
+        client_secret: "CLIENT_SECRET",
+        authorization_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        token_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        no_pkce: false,
+        scopes: ["Calendars.Read", "User.Read"],
+    },
+});
+OpenAIConnectors.outlookEmail = new Connector({
+    name: "Outlook Email",
+    server: new MCPServer({ serverLabel: "Outlook_Email", openaiConnectorId: "connector_outlookemail" }),
+    oauth: {
+        client_id: getEnvValue("MICROSOFT_CONNECTOR_OAUTH_CLIENT_ID"),
+        client_secret: "CLIENT_SECRET",
+        authorization_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        token_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        no_pkce: false,
+        scopes: ["User.Read", "Mail.Read"],
+    },
+});
+OpenAIConnectors.sharepoint = new Connector({
+    name: "Sharepoint",
+    server: new MCPServer({ serverLabel: "Sharepoint", openaiConnectorId: "connector_sharepoint" }),
+    oauth: {
+        client_id: getEnvValue("MICROSOFT_CONNECTOR_OAUTH_CLIENT_ID"),
+        client_secret: "CLIENT_SECRET",
+        authorization_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+        token_endpoint: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+        no_pkce: false,
+        scopes: ["Sites.Read.All", "Files.Read.All", "User.Read"],
+    },
+});
+OpenAIConnectors.all = [
+    OpenAIConnectors.dropbox,
+    OpenAIConnectors.gmail,
+    OpenAIConnectors.googleCalendar,
+    OpenAIConnectors.googleDrive,
+    OpenAIConnectors.microsoftTeams,
+    OpenAIConnectors.sharepoint,
+    OpenAIConnectors.outlookEmail,
+    OpenAIConnectors.outlookCalendar,
+];

package/dist/node/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/node/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/node/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;