@meshagent/meshagent 0.27.0 → 0.28.0

package/dist/esm/secrets-client.d.ts

@@ -1,5 +1,5 @@
 import { RoomClient } from "./room-client";
-import { FileResponse } from "./response";
+import { FileContent } from "./response";
 export interface SecretInfo {
     id: string;
     name: string;
@@ -22,7 +22,7 @@ export declare class SecretsClient {
     getSecret({ secretId, delegatedTo, }: {
         secretId: string;
         delegatedTo?: string;
-    }): Promise<FileResponse | null>;
+    }): Promise<FileContent | null>;
     listSecrets(): Promise<SecretInfo[]>;
     deleteSecret({ secretId, delegatedTo, }: {
         secretId: string;

package/dist/esm/secrets-client.js

@@ -1,4 +1,4 @@
-import { EmptyResponse, FileResponse, JsonResponse } from "./response";
+import { EmptyContent, FileContent, JsonContent } from "./response";
 export class SecretsClient {
     constructor({ room }) {
         this.client = room;
@@ -16,10 +16,10 @@ export class SecretsClient {
         if (forIdentity)
             req.for_identity = forIdentity;
         const response = await this.client.sendRequest("secrets.set_secret", req, data);
-        if (response instanceof EmptyResponse || response instanceof JsonResponse) {
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
     async getSecret({ secretId, delegatedTo, }) {
         const req = {
@@ -28,18 +28,18 @@ export class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.get_secret", req);
-        if (response instanceof EmptyResponse) {
+        if (response instanceof EmptyContent) {
             return null;
         }
-        if (response instanceof FileResponse) {
+        if (response instanceof FileContent) {
             return response;
         }
-        throw new Error("Invalid response received, expected FileResponse or EmptyResponse");
+        throw new Error("Invalid response received, expected FileContent or EmptyContent");
     }
     async listSecrets() {
         const response = await this.client.sendRequest("secrets.list_secrets", {});
-        if (!(response instanceof JsonResponse)) {
-            throw new Error("Invalid response received, expected JsonResponse");
+        if (!(response instanceof JsonContent)) {
+            throw new Error("Invalid response received, expected JsonContent");
         }
         const secrets = Array.isArray(response.json?.secrets) ? response.json.secrets : [];
         return secrets.map((item) => ({
@@ -56,10 +56,10 @@ export class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.delete_secret", req);
-        if (response instanceof EmptyResponse || response instanceof JsonResponse) {
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
     async deleteRequestedSecret({ url, type, delegatedTo, }) {
         const req = {
@@ -69,9 +69,9 @@ export class SecretsClient {
         if (delegatedTo)
             req.delegated_to = delegatedTo;
         const response = await this.client.sendRequest("secrets.delete_requested_secret", req);
-        if (response instanceof EmptyResponse || response instanceof JsonResponse) {
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
             return;
         }
-        throw new Error("Invalid response received, expected EmptyResponse or JsonResponse");
+        throw new Error("Invalid response received, expected EmptyContent or JsonContent");
     }
 }

package/dist/esm/storage-client.d.ts

@@ -1,6 +1,6 @@
 import { RoomClient } from "./room-client";
 import { RoomEvent } from "./room-event";
-import { FileResponse } from "./response";
+import { FileContent } from "./response";
 import { EventEmitter } from "./event-emitter";
 export declare class FileHandle {
     id: number;
@@ -32,7 +32,7 @@ export declare class StorageClient extends EventEmitter<RoomEvent> {
     exists(path: string): Promise<boolean>;
     write(handle: FileHandle, bytes: Uint8Array): Promise<void>;
     close(handle: FileHandle): Promise<void>;
-    download(path: string): Promise<FileResponse>;
+    download(path: string): Promise<FileContent>;
     downloadUrl(path: string): Promise<string>;
 }
 export {};

package/dist/esm/tool-content-type.d.ts

@@ -0,0 +1,13 @@
+export type ToolContentType = "json" | "text" | "file" | "link" | "empty";
+export declare class ToolContentSpec {
+    readonly types: ToolContentType[];
+    readonly stream: boolean;
+    readonly schema?: Record<string, unknown>;
+    constructor({ types, stream, schema, }: {
+        types: ToolContentType[];
+        stream?: boolean;
+        schema?: Record<string, unknown>;
+    });
+    toJson(): Record<string, unknown>;
+    static fromJson(value: unknown): ToolContentSpec | undefined;
+}

package/dist/esm/tool-content-type.js

@@ -0,0 +1,64 @@
+const SUPPORTED_TOOL_CONTENT_TYPES = new Set([
+    "json",
+    "text",
+    "file",
+    "link",
+    "empty",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export class ToolContentSpec {
+    constructor({ types, stream = false, schema, }) {
+        if (!Array.isArray(types) || types.length === 0) {
+            throw new Error("ToolContentSpec.types must contain at least one supported type");
+        }
+        for (const type of types) {
+            if (!SUPPORTED_TOOL_CONTENT_TYPES.has(type)) {
+                throw new Error(`Unsupported tool content type: ${String(type)}`);
+            }
+        }
+        this.types = [...types];
+        this.stream = stream;
+        this.schema = schema;
+    }
+    toJson() {
+        const value = {
+            types: [...this.types],
+            stream: this.stream,
+        };
+        if (this.schema !== undefined) {
+            value["schema"] = this.schema;
+        }
+        return value;
+    }
+    static fromJson(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (!isRecord(value)) {
+            throw new Error("ToolContentSpec must be a JSON object");
+        }
+        const rawTypes = value["types"];
+        if (!Array.isArray(rawTypes) || rawTypes.length === 0) {
+            throw new Error("ToolContentSpec.types must be a non-empty array");
+        }
+        const types = rawTypes.map((item) => {
+            if (typeof item !== "string") {
+                throw new Error("ToolContentSpec.types values must be strings");
+            }
+            if (!SUPPORTED_TOOL_CONTENT_TYPES.has(item)) {
+                throw new Error(`Unsupported tool content type: ${item}`);
+            }
+            return item;
+        });
+        const rawStream = value["stream"];
+        const stream = typeof rawStream === "boolean" ? rawStream : false;
+        const rawSchema = value["schema"];
+        if (rawSchema !== undefined && !isRecord(rawSchema)) {
+            throw new Error("ToolContentSpec.schema must be an object when provided");
+        }
+        const schema = rawSchema;
+        return new ToolContentSpec({ types, stream, schema });
+    }
+}

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

@@ -1,44 +1,31 @@
 import { RoomClient } from "./room-client";
-import { Response } from "./response";
-export declare class AgentDescription {
-    readonly name: string;
-    readonly title: string;
-    readonly description: string;
-    readonly outputSchema?: Record<string, any>;
-    readonly inputSchema?: Record<string, any>;
-    readonly labels: string[];
-    readonly supportsTools: boolean;
-    constructor({ name, title, description, outputSchema, inputSchema, labels, supportsTools, }: {
-        name: string;
-        title: string;
-        description: string;
-        outputSchema?: Record<string, any>;
-        inputSchema?: Record<string, any>;
-        labels?: string[];
-        supportsTools: boolean;
-    });
-    toJson(): Record<string, any>;
-    static fromJson(a: Record<string, any>): AgentDescription;
-}
+import { Content } from "./response";
+import { ToolContentSpec } from "./tool-content-type";
 export declare class ToolDescription {
     title: string;
     name: string;
     description: string;
-    inputSchema: Record<string, any>;
+    inputSpec?: ToolContentSpec;
+    outputSpec?: ToolContentSpec;
     defs?: Record<string, any>;
     thumbnailUrl?: string;
     pricing?: string;
     supportsContext?: boolean;
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }: {
         title: string;
         name: string;
         description: string;
-        inputSchema: Record<string, any>;
+        inputSchema?: Record<string, any>;
+        inputSpec?: ToolContentSpec;
+        outputSpec?: ToolContentSpec;
+        outputSchema?: Record<string, any>;
         thumbnailUrl?: string;
         defs?: Record<string, any>;
         pricing?: string;
         supportsContext?: boolean;
     });
+    get inputSchema(): Record<string, any> | undefined;
+    get outputSchema(): Record<string, any> | undefined;
 }
 export declare class ToolkitDescription {
     readonly title: string;
@@ -87,5 +74,5 @@ export declare class AgentsClient {
         toolkit: string;
         tool: string;
         arguments: Record<string, any>;
-    }): Promise<Response>;
+    }): Promise<Content>;
 }

package/dist/node/agent-client.js

@@ -1,55 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsClient = exports.ToolkitConfiguration = exports.ToolkitDescription = exports.ToolDescription = exports.AgentDescription = void 0;
-class AgentDescription {
-    constructor({ name, title, description, outputSchema, inputSchema, labels, supportsTools, }) {
-        this.name = name;
-        this.title = title;
-        this.description = description;
-        this.outputSchema = outputSchema;
-        this.inputSchema = inputSchema;
-        this.labels = Array.isArray(labels) ? labels : [];
-        this.supportsTools = supportsTools ?? false;
-    }
-    toJson() {
-        return {
-            name: this.name,
-            title: this.title,
-            description: this.description,
-            input_schema: this.inputSchema,
-            output_schema: this.outputSchema,
-            labels: this.labels,
-            supports_tools: this.supportsTools,
-        };
-    }
-    static fromJson(a) {
-        let labels = [];
-        if (Array.isArray(a["labels"])) {
-            labels = a["labels"].filter((item) => typeof item === "string");
-        }
-        return new AgentDescription({
-            name: a["name"],
-            title: a["title"] ?? "",
-            description: a["description"] ?? "",
-            inputSchema: a["input_schema"] ?? undefined,
-            outputSchema: a["output_schema"] ?? undefined,
-            supportsTools: a["supports_tools"] === true,
-            labels,
-        });
-    }
-}
-exports.AgentDescription = AgentDescription;
+exports.AgentsClient = exports.ToolkitConfiguration = exports.ToolkitDescription = exports.ToolDescription = void 0;
+const tool_content_type_1 = require("./tool-content-type");
 class ToolDescription {
-    constructor({ title, name, description, inputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
+    constructor({ title, name, description, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl, defs, pricing, supportsContext }) {
         this.title = title;
         this.name = name;
         this.description = description;
-        this.inputSchema = inputSchema;
+        if (inputSpec !== undefined && inputSchema !== undefined) {
+            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+                types: [...inputSpec.types],
+                stream: inputSpec.stream,
+                schema: inputSchema,
+            });
+        }
+        else if (inputSpec !== undefined) {
+            this.inputSpec = inputSpec;
+        }
+        else if (inputSchema !== undefined) {
+            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: inputSchema,
+            });
+        }
+        if (outputSpec !== undefined && outputSchema !== undefined) {
+            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+                types: [...outputSpec.types],
+                stream: outputSpec.stream,
+                schema: outputSchema,
+            });
+        }
+        else if (outputSpec !== undefined) {
+            this.outputSpec = outputSpec;
+        }
+        else if (outputSchema !== undefined) {
+            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: outputSchema,
+            });
+        }
         this.thumbnailUrl = thumbnailUrl;
         this.defs = defs;
         this.pricing = pricing;
         this.supportsContext = supportsContext ?? false;
     }
+    get inputSchema() {
+        return this.inputSpec?.schema;
+    }
+    get outputSchema() {
+        return this.outputSpec?.schema;
+    }
 }
 exports.ToolDescription = ToolDescription;
 class ToolkitDescription {
@@ -78,9 +80,12 @@ class ToolkitDescription {
                 name: tool.name,
                 title: tool.title,
                 description: tool.description,
-                input_schema: tool.inputSchema,
+                input_spec: tool.inputSpec?.toJson(),
+                output_spec: tool.outputSpec?.toJson(),
                 thumbnail_url: tool.thumbnailUrl,
                 defs: tool.defs,
+                pricing: tool.pricing,
+                supports_context: tool.supportsContext,
             })),
         };
     }
@@ -99,10 +104,13 @@ class ToolkitDescription {
                     name: tool["name"],
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
+                    inputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["input_spec"]),
+                    outputSchema: tool["output_schema"],
+                    outputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["output_spec"]),
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supportsContext"],
+                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -115,10 +123,13 @@ class ToolkitDescription {
                     name: toolName,
                     description: tool["description"],
                     inputSchema: tool["input_schema"],
+                    inputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["input_spec"]),
+                    outputSchema: tool["output_schema"],
+                    outputSpec: tool_content_type_1.ToolContentSpec.fromJson(tool["output_spec"]),
                     thumbnailUrl: tool["thumbnail_url"],
                     defs: tool["defs"],
                     pricing: tool["pricing"],
-                    supportsContext: tool["supportsContext"],
+                    supportsContext: tool["supports_context"] ?? tool["supportsContext"],
                 }));
             }
         }
@@ -185,7 +196,15 @@ class AgentsClient {
         return toolkits;
     }
     async invokeTool(params) {
-        return await this.client.sendRequest("agent.invoke_tool", params);
+        const request = {
+            toolkit: params.toolkit,
+            tool: params.tool,
+            arguments: {
+                type: "json",
+                json: params.arguments,
+            },
+        };
+        return await this.client.sendRequest("agent.invoke_tool", request);
     }
 }
 exports.AgentsClient = AgentsClient;

package/dist/node/agent.d.ts

@@ -1,47 +1,27 @@
 import { RoomClient } from "./room-client";
 import { RequiredToolkit } from "./requirement";
-import { Response } from "./response";
-export declare class AgentChatContext {
-    messages: Array<Record<string, any>>;
-    readonly systemRole: string;
-    constructor({ messages, systemRole }: {
-        messages?: Array<Record<string, any>>;
-        systemRole?: string;
-    });
-    appendRules(rules: string[]): void;
-    appendUserMessage(message: string): void;
-    appendUserImage(url: string): void;
-    copy(): AgentChatContext;
-    toJson(): Record<string, any>;
-    static fromJson(json: Record<string, any>): AgentChatContext;
-}
-export declare class TaskContext {
-    private readonly _jwt;
-    private readonly _chat;
-    private readonly _apiUrl;
-    constructor({ chat, jwt, api_url }: {
-        chat: AgentChatContext;
-        jwt: string;
-        api_url: string;
-    });
-    get chat(): AgentChatContext;
-    get jwt(): string;
-    get api_url(): string;
-}
+import { Content } from "./response";
+import { ToolContentSpec } from "./tool-content-type";
 export declare abstract class Tool {
     readonly name: string;
     readonly description: string;
     readonly title: string;
-    readonly inputSchema: Record<string, any>;
+    readonly inputSpec?: ToolContentSpec;
+    readonly outputSpec?: ToolContentSpec;
     readonly thumbnailUrl?: string;
-    constructor({ name, description, title, inputSchema, thumbnailUrl }: {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }: {
         name: string;
         description: string;
         title: string;
-        inputSchema: Record<string, any>;
+        inputSchema?: Record<string, any>;
+        inputSpec?: ToolContentSpec;
+        outputSpec?: ToolContentSpec;
+        outputSchema?: Record<string, any>;
         thumbnailUrl?: string;
     });
-    abstract execute(arguments_: Record<string, any>): Promise<Response>;
+    get inputSchema(): Record<string, any> | undefined;
+    get outputSchema(): Record<string, any> | undefined;
+    abstract execute(arguments_: Record<string, any>): Promise<Content>;
 }
 export declare abstract class Toolkit {
     readonly tools: Tool[];
@@ -52,7 +32,7 @@ export declare abstract class Toolkit {
     });
     getTool(name: string): Tool;
     getTools(): Record<string, any>;
-    execute(name: string, args: Record<string, any>): Promise<Response>;
+    execute(name: string, args: Record<string, any>): Promise<Content>;
 }
 export declare abstract class RemoteToolkit extends Toolkit {
     protected readonly client: RoomClient;
@@ -96,5 +76,5 @@ export declare abstract class RemoteTaskRunner {
     });
     start(): Promise<void>;
     stop(): Promise<void>;
-    abstract ask(context: TaskContext, arguments_: Record<string, any>): Promise<Record<string, any>>;
+    abstract ask(arguments_: Record<string, any>): Promise<Record<string, any>>;
 }

package/dist/node/agent.js

@@ -1,85 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteTaskRunner = exports.RemoteToolkit = exports.Toolkit = exports.Tool = exports.TaskContext = exports.AgentChatContext = void 0;
+exports.RemoteTaskRunner = exports.RemoteToolkit = exports.Toolkit = exports.Tool = void 0;
 const response_1 = require("./response");
+const tool_content_type_1 = require("./tool-content-type");
 const utils_1 = require("./utils");
-class AgentChatContext {
-    constructor({ messages, systemRole = "system" }) {
-        this.messages = messages ? [...messages] : [];
-        this.systemRole = systemRole;
-    }
-    appendRules(rules) {
-        let systemMessage = this.messages.find((m) => m["role"] === this.systemRole);
-        if (!systemMessage) {
-            systemMessage = { role: this.systemRole, content: "" };
-            this.messages.push(systemMessage);
-        }
-        const plan = `
-        Rules:
-            -${rules.join("\n-")}
-        `;
-        systemMessage["content"] += plan;
-    }
-    appendUserMessage(message) {
-        this.messages.push({ role: "user", content: message });
-    }
-    appendUserImage(url) {
-        this.messages.push({
-            role: "user",
-            content: [
-                {
-                    type: "image_url",
-                    image_url: { url: url, detail: "auto" },
-                },
-            ],
-        });
-    }
-    copy() {
-        const cloned = JSON.parse(JSON.stringify(this.messages));
-        return new AgentChatContext({
-            messages: cloned,
-            systemRole: this.systemRole,
-        });
-    }
-    toJson() {
-        return {
-            messages: this.messages,
-            system_role: this.systemRole,
-        };
-    }
-    static fromJson(json) {
-        return new AgentChatContext({
-            messages: json["messages"],
-            systemRole: json["system_role"] || "system",
-        });
-    }
-}
-exports.AgentChatContext = AgentChatContext;
-class TaskContext {
-    constructor({ chat, jwt, api_url }) {
-        this._jwt = jwt;
-        this._chat = chat;
-        this._apiUrl = api_url;
-    }
-    get chat() {
-        return this._chat;
-    }
-    get jwt() {
-        return this._jwt;
-    }
-    get api_url() {
-        return this._apiUrl;
-    }
-}
-exports.TaskContext = TaskContext;
 class Tool {
-    constructor({ name, description, title, inputSchema, thumbnailUrl }) {
+    constructor({ name, description, title, inputSchema, inputSpec, outputSpec, outputSchema, thumbnailUrl }) {
         this.name = name;
         this.description = description;
         this.title = title;
-        this.inputSchema = inputSchema;
+        if (inputSpec !== undefined && inputSchema !== undefined) {
+            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+                types: [...inputSpec.types],
+                stream: inputSpec.stream,
+                schema: inputSchema,
+            });
+        }
+        else if (inputSpec !== undefined) {
+            this.inputSpec = inputSpec;
+        }
+        else if (inputSchema !== undefined) {
+            this.inputSpec = new tool_content_type_1.ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: inputSchema,
+            });
+        }
+        if (outputSpec !== undefined && outputSchema !== undefined) {
+            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+                types: [...outputSpec.types],
+                stream: outputSpec.stream,
+                schema: outputSchema,
+            });
+        }
+        else if (outputSpec !== undefined) {
+            this.outputSpec = outputSpec;
+        }
+        else if (outputSchema !== undefined) {
+            this.outputSpec = new tool_content_type_1.ToolContentSpec({
+                types: ["json"],
+                stream: false,
+                schema: outputSchema,
+            });
+        }
         this.thumbnailUrl = thumbnailUrl;
     }
+    get inputSchema() {
+        return this.inputSpec?.schema;
+    }
+    get outputSchema() {
+        return this.outputSpec?.schema;
+    }
 }
 exports.Tool = Tool;
 class Toolkit {
@@ -100,7 +71,8 @@ class Toolkit {
             json[tool.name] = {
                 description: tool.description,
                 title: tool.title,
-                input_schema: tool.inputSchema,
+                input_spec: tool.inputSpec?.toJson(),
+                output_spec: tool.outputSpec?.toJson(),
                 thumbnail_url: tool.thumbnailUrl,
             };
         }
@@ -150,12 +122,32 @@ class RemoteToolkit extends Toolkit {
         try {
             const [message, _] = (0, utils_1.unpackMessage)(data);
             const toolName = message["name"];
-            const args = message["arguments"];
+            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)}'`);
+                }
+            }
+            else {
+                args = rawArguments ?? {};
+            }
             const response = await this.execute(toolName, args);
             await this.client.protocol.send("agent.tool_call_response", response.pack(), messageId);
         }
         catch (e) {
-            const err = new response_1.ErrorResponse({ text: String(e) });
+            const err = new response_1.ErrorContent({ text: String(e) });
             await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
         }
     }

package/dist/node/database-client.js

@@ -69,7 +69,7 @@ class DatabaseClient {
             params,
         };
         const response = await this.room.sendRequest("database.sql", payload);
-        if (response instanceof response_1.JsonResponse) {
+        if (response instanceof response_1.JsonContent) {
             if (response?.json?.results) {
                 return response.json.results;
             }
@@ -100,7 +100,7 @@ class DatabaseClient {
             payload.vector = vector;
         }
         const response = await this.room.sendRequest("database.search", payload);
-        if (response instanceof response_1.JsonResponse) {
+        if (response instanceof response_1.JsonContent) {
             if (response?.json?.results) {
                 return response.json.results;
             }

package/dist/node/index.d.ts

@@ -26,4 +26,5 @@ export * from './stream-controller';
 export * from './sync-client';
 export * from './api_keys';
 export * from './helpers';
+export * from './tool-content-type';
 export * from './utils';