@lov3kaizen/agentsea-core 0.3.1 → 0.5.0

package/dist/index.mjs

@@ -83,8 +83,17 @@ __export(index_exports, {
   VoiceType: () => VoiceType,
   Workflow: () => Workflow,
   WorkflowFactory: () => WorkflowFactory,
+  calculatorClient: () => calculatorClient,
+  calculatorDef: () => calculatorDef,
+  calculatorServer: () => calculatorServer,
   calculatorTool: () => calculatorTool,
+  clientTool: () => clientTool,
   createACPTools: () => createACPTools,
+  createAnthropicProvider: () => createAnthropicProvider,
+  createGeminiProvider: () => createGeminiProvider,
+  createOllamaProvider: () => createOllamaProvider,
+  createOpenAIProvider: () => createOpenAIProvider,
+  createProvider: () => createProvider,
   defaultLogger: () => defaultLogger,
   figmaGetCommentsTool: () => figmaGetCommentsTool,
   figmaGetFileTool: () => figmaGetFileTool,
@@ -97,14 +106,19 @@ __export(index_exports, {
   globalMetrics: () => globalMetrics,
   globalTracer: () => globalTracer,
   httpRequestTool: () => httpRequestTool,
+  hybridTool: () => hybridTool,
   mcpToolToAgenticTool: () => mcpToolToAgenticTool,
   n8nExecuteWorkflowTool: () => n8nExecuteWorkflowTool,
   n8nGetExecutionTool: () => n8nGetExecutionTool,
   n8nGetWorkflowTool: () => n8nGetWorkflowTool,
   n8nListWorkflowsTool: () => n8nListWorkflowsTool,
   n8nTriggerWebhookTool: () => n8nTriggerWebhookTool,
+  serverTool: () => serverTool,
   stringTransformTool: () => stringTransformTool,
-  textSummaryTool: () => textSummaryTool
+  textSummaryTool: () => textSummaryTool,
+  toLegacyTool: () => toLegacyTool,
+  toLegacyTools: () => toLegacyTools,
+  toolDefinition: () => toolDefinition
 });
 
 // src/types/index.ts
@@ -366,6 +380,7 @@ var Agent = class {
             // Will be set by execute()
             iterations: this.iterationCount
           },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
           finishReason: llmResponse.stopReason
         };
         if (this.config.outputFormat && this.config.outputFormat !== "text") {
@@ -762,7 +777,7 @@ var httpRequestTool = {
     url: z2.string().url().describe("The URL to make the request to"),
     method: z2.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("GET").describe("HTTP method"),
     headers: z2.record(z2.string()).optional().describe("HTTP headers"),
-    body: z2.any().optional().describe("Request body (for POST, PUT, PATCH)"),
+    body: z2.unknown().optional().describe("Request body (for POST, PUT, PATCH)"),
     timeout: z2.number().optional().default(1e4).describe("Request timeout in milliseconds")
   }),
   execute: async (params) => {
@@ -1220,7 +1235,7 @@ var n8nExecuteWorkflowTool = {
   description: "Execute an n8n workflow by ID or name. Optionally pass input data to the workflow.",
   parameters: z6.object({
     workflowId: z6.string().describe("The ID of the workflow to execute"),
-    data: z6.any().optional().describe("Input data to pass to the workflow execution"),
+    data: z6.unknown().optional().describe("Input data to pass to the workflow execution"),
     waitForCompletion: z6.boolean().default(true).describe("Wait for workflow execution to complete before returning"),
     apiKey: z6.string().optional().describe("n8n API key (or use N8N_API_KEY env var)"),
     baseUrl: z6.string().optional().describe("n8n base URL (or use N8N_BASE_URL env var)")
@@ -1337,7 +1352,7 @@ var n8nTriggerWebhookTool = {
   parameters: z6.object({
     webhookPath: z6.string().describe('The webhook path (e.g., "webhook/my-workflow")'),
     method: z6.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("POST").describe("HTTP method for the webhook"),
-    data: z6.any().optional().describe("Data to send to the webhook"),
+    data: z6.unknown().optional().describe("Data to send to the webhook"),
     headers: z6.record(z6.string()).optional().describe("Additional headers to include"),
     baseUrl: z6.string().optional().describe("n8n base URL (or use N8N_BASE_URL env var)")
   }),
@@ -1428,6 +1443,162 @@ async function pollExecutionStatus(executionId, apiKey, baseUrl, maxAttempts = 3
   );
 }
 
+// src/tools/built-in/calculator.isomorphic.ts
+import { z as z8 } from "zod";
+
+// src/tools/tool-definition.ts
+import { z as z7 } from "zod";
+function toolDefinition(options) {
+  const {
+    name,
+    description,
+    inputSchema,
+    outputSchema = z7.unknown(),
+    needsApproval = false,
+    retryConfig
+  } = options;
+  const createServerTool = (execute) => {
+    const wrappedExecute = async (input, context) => {
+      const validatedInput = inputSchema.parse(input);
+      const result = await execute(validatedInput, context);
+      if (outputSchema) {
+        return outputSchema.parse(result);
+      }
+      return result;
+    };
+    return {
+      name,
+      description,
+      inputSchema,
+      outputSchema,
+      needsApproval,
+      retryConfig,
+      environment: "server",
+      execute: wrappedExecute,
+      toTool() {
+        return {
+          name,
+          description,
+          parameters: inputSchema,
+          execute: wrappedExecute,
+          retryConfig
+        };
+      }
+    };
+  };
+  const createClientTool = (execute) => {
+    const wrappedExecute = async (input, context) => {
+      const validatedInput = inputSchema.parse(input);
+      const result = await execute(validatedInput, context);
+      if (outputSchema) {
+        return outputSchema.parse(result);
+      }
+      return result;
+    };
+    return {
+      name,
+      description,
+      inputSchema,
+      outputSchema,
+      needsApproval,
+      retryConfig,
+      environment: "client",
+      execute: wrappedExecute,
+      toTool() {
+        return {
+          name,
+          description,
+          parameters: inputSchema,
+          execute: wrappedExecute,
+          retryConfig
+        };
+      }
+    };
+  };
+  return {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    needsApproval,
+    retryConfig,
+    server: createServerTool,
+    client: createClientTool,
+    toTool(execute) {
+      return createServerTool(execute).toTool();
+    }
+  };
+}
+function hybridTool(options) {
+  const def = toolDefinition(options);
+  const serverTool2 = def.server(options.server);
+  const clientTool2 = def.client(options.client);
+  return {
+    name: def.name,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    outputSchema: def.outputSchema,
+    needsApproval: def.needsApproval,
+    retryConfig: def.retryConfig,
+    server: serverTool2,
+    client: clientTool2,
+    toTool() {
+      return serverTool2.toTool();
+    }
+  };
+}
+function serverTool(options) {
+  return toolDefinition(options).server(options.execute);
+}
+function clientTool(options) {
+  return toolDefinition(options).client(options.execute);
+}
+function toLegacyTool(tool) {
+  return tool.toTool();
+}
+function toLegacyTools(tools) {
+  return tools.map(toLegacyTool);
+}
+
+// src/tools/built-in/calculator.isomorphic.ts
+var calculatorInputSchema = z8.object({
+  operation: z8.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
+  a: z8.number().describe("First number"),
+  b: z8.number().describe("Second number")
+});
+var calculatorOutputSchema = z8.object({
+  result: z8.number().describe("The result of the calculation")
+});
+var calculatorDef = toolDefinition({
+  name: "calculator",
+  description: "Perform basic arithmetic operations (add, subtract, multiply, divide)",
+  inputSchema: calculatorInputSchema,
+  outputSchema: calculatorOutputSchema
+});
+function calculate(operation, a, b) {
+  switch (operation) {
+    case "add":
+      return { result: a + b };
+    case "subtract":
+      return { result: a - b };
+    case "multiply":
+      return { result: a * b };
+    case "divide":
+      if (b === 0) {
+        throw new Error("Cannot divide by zero");
+      }
+      return { result: a / b };
+    default:
+      throw new Error(`Unknown operation: ${operation}`);
+  }
+}
+var calculatorServer = calculatorDef.server(({ operation, a, b }) => {
+  return Promise.resolve(calculate(operation, a, b));
+});
+var calculatorClient = calculatorDef.client(({ operation, a, b }) => {
+  return calculate(operation, a, b);
+});
+
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -1454,6 +1625,7 @@ var AnthropicProvider = class {
       temperature: config.temperature,
       system: config.systemPrompt,
       messages: anthropicMessages,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       tools,
       top_p: config.topP,
       stop_sequences: config.stopSequences
@@ -1485,6 +1657,7 @@ var AnthropicProvider = class {
       temperature: config.temperature,
       system: config.systemPrompt,
       messages: anthropicMessages,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       tools,
       top_p: config.topP,
       stop_sequences: config.stopSequences
@@ -1548,6 +1721,7 @@ var AnthropicProvider = class {
               type: "tool_result",
               tool_use_id: message.toolCallId || "",
               content: message.content
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
             });
           }
         }
@@ -1807,8 +1981,9 @@ var GeminiProvider = class {
    */
   parseToolCalls(response) {
     const toolCalls = [];
-    if (response.rawResponse?.functionCalls) {
-      for (const call of response.rawResponse.functionCalls()) {
+    const rawResponse = response.rawResponse;
+    if (rawResponse?.functionCalls) {
+      for (const call of rawResponse.functionCalls()) {
         toolCalls.push({
           id: `call-${Date.now()}-${Math.random()}`,
           tool: call.name,
@@ -1998,7 +2173,7 @@ var OllamaProvider = class {
   parseToolCalls(response) {
     const rawResponse = response.rawResponse;
     const toolCalls = [];
-    if (rawResponse.message?.tool_calls) {
+    if (rawResponse?.message?.tool_calls) {
       for (const toolCall of rawResponse.message.tool_calls) {
         toolCalls.push({
           id: toolCall.id || Math.random().toString(36),
@@ -2012,6 +2187,7 @@ var OllamaProvider = class {
   /**
    * Convert generic messages to Ollama format
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   convertMessages(messages, systemPrompt) {
     const converted = [];
     if (systemPrompt) {
@@ -2046,6 +2222,7 @@ var OllamaProvider = class {
   /**
    * Make a request to Ollama API
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async makeRequest(endpoint, payload) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -2335,6 +2512,91 @@ var VLLMProvider = class extends OpenAICompatibleProvider {
   }
 };
 
+// src/providers/type-safe-provider.ts
+function createProvider(config) {
+  let provider;
+  switch (config.provider) {
+    case "anthropic":
+      provider = new AnthropicProvider();
+      break;
+    case "openai":
+      provider = new OpenAIProvider();
+      break;
+    case "gemini":
+      provider = new GeminiProvider();
+      break;
+    case "ollama":
+      provider = new OllamaProvider();
+      break;
+    default: {
+      const exhaustiveCheck = config;
+      throw new Error(`Unknown provider: ${exhaustiveCheck.provider}`);
+    }
+  }
+  return {
+    config,
+    provider,
+    getModelInfo() {
+      return (0, types_exports.getModelInfo)(config.model);
+    },
+    supportsCapability(capability) {
+      return (0, types_exports.modelSupportsCapability)(config.model, capability);
+    }
+  };
+}
+function createAnthropicProvider(config, options) {
+  const provider = new AnthropicProvider(options?.apiKey);
+  return {
+    config,
+    provider,
+    getModelInfo() {
+      return (0, types_exports.getModelInfo)(config.model);
+    },
+    supportsCapability(capability) {
+      return (0, types_exports.modelSupportsCapability)(config.model, capability);
+    }
+  };
+}
+function createOpenAIProvider(config, options) {
+  const provider = new OpenAIProvider(options?.apiKey);
+  return {
+    config,
+    provider,
+    getModelInfo() {
+      return (0, types_exports.getModelInfo)(config.model);
+    },
+    supportsCapability(capability) {
+      return (0, types_exports.modelSupportsCapability)(config.model, capability);
+    }
+  };
+}
+function createGeminiProvider(config, options) {
+  const provider = new GeminiProvider(options?.apiKey);
+  return {
+    config,
+    provider,
+    getModelInfo() {
+      return (0, types_exports.getModelInfo)(config.model);
+    },
+    supportsCapability(capability) {
+      return (0, types_exports.modelSupportsCapability)(config.model, capability);
+    }
+  };
+}
+function createOllamaProvider(config, options) {
+  const provider = new OllamaProvider(options);
+  return {
+    config,
+    provider,
+    getModelInfo() {
+      return (0, types_exports.getModelInfo)(config.model);
+    },
+    supportsCapability(capability) {
+      return (0, types_exports.modelSupportsCapability)(config.model, capability);
+    }
+  };
+}
+
 // src/memory/buffer-memory.ts
 var BufferMemory = class {
   constructor(maxMessages) {
@@ -3826,7 +4088,7 @@ var MCPClient = class extends EventEmitter2 {
 };
 
 // src/mcp/tool-adapter.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 function mcpToolToAgenticTool(mcpTool, client) {
   const zodSchema = jsonSchemaToZod(mcpTool.inputSchema);
   return {
@@ -3834,7 +4096,10 @@ function mcpToolToAgenticTool(mcpTool, client) {
     description: mcpTool.description,
     parameters: zodSchema,
     execute: async (params, _context) => {
-      const response = await client.callTool(mcpTool.name, params);
+      const response = await client.callTool(
+        mcpTool.name,
+        params
+      );
       if (response.isError) {
         throw new Error(
           `MCP tool error: ${response.content[0]?.text || "Unknown error"}`
@@ -3858,26 +4123,30 @@ function jsonSchemaToZod(schema) {
       let zodType;
       switch (propSchema.type) {
         case "string":
-          zodType = z7.string();
-          if (propSchema.description) {
+          zodType = z9.string();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "number":
-          zodType = z7.number();
-          if (propSchema.description) {
+          zodType = z9.number();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "boolean":
-          zodType = z7.boolean();
-          if (propSchema.description) {
+          zodType = z9.boolean();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "array":
-          zodType = z7.array(jsonSchemaToZod(propSchema.items || {}));
-          if (propSchema.description) {
+          zodType = z9.array(
+            jsonSchemaToZod(
+              propSchema.items || {}
+            )
+          );
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
@@ -3885,16 +4154,17 @@ function jsonSchemaToZod(schema) {
           zodType = jsonSchemaToZod(propSchema);
           break;
         default:
-          zodType = z7.any();
+          zodType = z9.any();
       }
-      if (!schema.required?.includes(key)) {
+      const required = schema.required;
+      if (!required?.includes(key)) {
         zodType = zodType.optional();
       }
       shape[key] = zodType;
     }
-    return z7.object(shape);
+    return z9.object(shape);
   }
-  return z7.any();
+  return z9.any();
 }
 
 // src/mcp/registry.ts
@@ -4291,7 +4561,7 @@ var ACPClient = class {
 };
 
 // src/acp/tools.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 function createACPTools(client) {
   return [
     createSearchProductsTool(client),
@@ -4314,15 +4584,15 @@ function createSearchProductsTool(client) {
   return {
     name: "acp_search_products",
     description: "Search for products in the commerce catalog. Supports filtering by query text, category, price range, and sorting.",
-    parameters: z8.object({
-      query: z8.string().optional().describe("Search query text"),
-      category: z8.string().optional().describe("Product category filter"),
-      minPrice: z8.number().optional().describe("Minimum price filter"),
-      maxPrice: z8.number().optional().describe("Maximum price filter"),
-      limit: z8.number().optional().default(10).describe("Maximum number of results"),
-      offset: z8.number().optional().default(0).describe("Pagination offset"),
-      sortBy: z8.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
-      sortOrder: z8.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
+    parameters: z10.object({
+      query: z10.string().optional().describe("Search query text"),
+      category: z10.string().optional().describe("Product category filter"),
+      minPrice: z10.number().optional().describe("Minimum price filter"),
+      maxPrice: z10.number().optional().describe("Maximum price filter"),
+      limit: z10.number().optional().default(10).describe("Maximum number of results"),
+      offset: z10.number().optional().default(0).describe("Pagination offset"),
+      sortBy: z10.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
+      sortOrder: z10.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
     }),
     execute: async (params) => {
       const response = await client.searchProducts(params);
@@ -4341,8 +4611,8 @@ function createGetProductTool(client) {
   return {
     name: "acp_get_product",
     description: "Get detailed information about a specific product by its ID.",
-    parameters: z8.object({
-      productId: z8.string().describe("Product ID")
+    parameters: z10.object({
+      productId: z10.string().describe("Product ID")
     }),
     execute: async (params) => {
       const response = await client.getProduct(params.productId);
@@ -4357,7 +4627,7 @@ function createCreateCartTool(client) {
   return {
     name: "acp_create_cart",
     description: "Create a new shopping cart for the customer. Returns the cart ID for subsequent operations.",
-    parameters: z8.object({}),
+    parameters: z10.object({}),
     execute: async () => {
       const response = await client.createCart();
       if (response.error) {
@@ -4371,14 +4641,14 @@ function createAddToCartTool(client) {
   return {
     name: "acp_add_to_cart",
     description: "Add a product to the shopping cart with specified quantity.",
-    parameters: z8.object({
-      cartId: z8.string().describe("Cart ID"),
-      productId: z8.string().describe("Product ID to add"),
-      variantId: z8.string().optional().describe("Product variant ID"),
-      quantity: z8.number().min(1).describe("Quantity to add"),
-      price: z8.object({
-        amount: z8.number().describe("Price amount"),
-        currency: z8.string().describe("Currency code (e.g., USD, EUR)")
+    parameters: z10.object({
+      cartId: z10.string().describe("Cart ID"),
+      productId: z10.string().describe("Product ID to add"),
+      variantId: z10.string().optional().describe("Product variant ID"),
+      quantity: z10.number().min(1).describe("Quantity to add"),
+      price: z10.object({
+        amount: z10.number().describe("Price amount"),
+        currency: z10.string().describe("Currency code (e.g., USD, EUR)")
       }).describe("Product price")
     }),
     execute: async (params) => {
@@ -4401,10 +4671,10 @@ function createUpdateCartItemTool(client) {
   return {
     name: "acp_update_cart_item",
     description: "Update the quantity of an item in the shopping cart.",
-    parameters: z8.object({
-      cartId: z8.string().describe("Cart ID"),
-      productId: z8.string().describe("Product ID to update"),
-      quantity: z8.number().min(0).describe("New quantity (0 to remove)")
+    parameters: z10.object({
+      cartId: z10.string().describe("Cart ID"),
+      productId: z10.string().describe("Product ID to update"),
+      quantity: z10.number().min(0).describe("New quantity (0 to remove)")
     }),
     execute: async (params) => {
       const response = await client.updateCartItem(
@@ -4425,9 +4695,9 @@ function createRemoveFromCartTool(client) {
   return {
     name: "acp_remove_from_cart",
     description: "Remove a product from the shopping cart.",
-    parameters: z8.object({
-      cartId: z8.string().describe("Cart ID"),
-      productId: z8.string().describe("Product ID to remove")
+    parameters: z10.object({
+      cartId: z10.string().describe("Cart ID"),
+      productId: z10.string().describe("Product ID to remove")
     }),
     execute: async (params) => {
       const response = await client.removeFromCart(
@@ -4447,8 +4717,8 @@ function createGetCartTool(client) {
   return {
     name: "acp_get_cart",
     description: "Get the current state of a shopping cart including all items and total amount.",
-    parameters: z8.object({
-      cartId: z8.string().describe("Cart ID")
+    parameters: z10.object({
+      cartId: z10.string().describe("Cart ID")
     }),
     execute: async (params) => {
       const response = await client.getCart(params.cartId);
@@ -4463,12 +4733,12 @@ function createCheckoutTool(client) {
   return {
     name: "acp_create_checkout",
     description: "Create a checkout session from a shopping cart to begin the purchase process.",
-    parameters: z8.object({
-      cartId: z8.string().describe("Cart ID"),
-      customer: z8.object({
-        email: z8.string().email().describe("Customer email"),
-        name: z8.string().optional().describe("Customer name"),
-        phone: z8.string().optional().describe("Customer phone number")
+    parameters: z10.object({
+      cartId: z10.string().describe("Cart ID"),
+      customer: z10.object({
+        email: z10.string().email().describe("Customer email"),
+        name: z10.string().optional().describe("Customer name"),
+        phone: z10.string().optional().describe("Customer phone number")
       }).optional().describe("Customer information")
     }),
     execute: async (params) => {
@@ -4489,15 +4759,15 @@ function createUpdateShippingAddressTool(client) {
   return {
     name: "acp_update_shipping_address",
     description: "Update the shipping address for a checkout session.",
-    parameters: z8.object({
-      sessionId: z8.string().describe("Checkout session ID"),
-      address: z8.object({
-        line1: z8.string().describe("Address line 1"),
-        line2: z8.string().optional().describe("Address line 2"),
-        city: z8.string().describe("City"),
-        state: z8.string().optional().describe("State/Province"),
-        postalCode: z8.string().describe("Postal/ZIP code"),
-        country: z8.string().describe("Country code (e.g., US, GB)")
+    parameters: z10.object({
+      sessionId: z10.string().describe("Checkout session ID"),
+      address: z10.object({
+        line1: z10.string().describe("Address line 1"),
+        line2: z10.string().optional().describe("Address line 2"),
+        city: z10.string().describe("City"),
+        state: z10.string().optional().describe("State/Province"),
+        postalCode: z10.string().describe("Postal/ZIP code"),
+        country: z10.string().describe("Country code (e.g., US, GB)")
       }).describe("Shipping address")
     }),
     execute: async (params) => {
@@ -4518,12 +4788,12 @@ function createUpdatePaymentMethodTool(client) {
   return {
     name: "acp_update_payment_method",
     description: "Update the payment method for a checkout session.",
-    parameters: z8.object({
-      sessionId: z8.string().describe("Checkout session ID"),
-      paymentMethod: z8.object({
-        type: z8.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
-        token: z8.string().optional().describe("Payment token"),
-        delegatedProvider: z8.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
+    parameters: z10.object({
+      sessionId: z10.string().describe("Checkout session ID"),
+      paymentMethod: z10.object({
+        type: z10.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
+        token: z10.string().optional().describe("Payment token"),
+        delegatedProvider: z10.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
       }).describe("Payment method details")
     }),
     execute: async (params) => {
@@ -4544,8 +4814,8 @@ function createCompleteCheckoutTool(client) {
   return {
     name: "acp_complete_checkout",
     description: "Complete the checkout process and create an order. This finalizes the purchase.",
-    parameters: z8.object({
-      sessionId: z8.string().describe("Checkout session ID")
+    parameters: z10.object({
+      sessionId: z10.string().describe("Checkout session ID")
     }),
     execute: async (params) => {
       const response = await client.completeCheckout(params.sessionId);
@@ -4562,8 +4832,8 @@ function createGetOrderTool(client) {
   return {
     name: "acp_get_order",
     description: "Get detailed information about an order by its ID.",
-    parameters: z8.object({
-      orderId: z8.string().describe("Order ID")
+    parameters: z10.object({
+      orderId: z10.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrder(params.orderId);
@@ -4578,8 +4848,8 @@ function createCancelOrderTool(client) {
   return {
     name: "acp_cancel_order",
     description: "Cancel an order. Only orders that have not been shipped can be cancelled.",
-    parameters: z8.object({
-      orderId: z8.string().describe("Order ID")
+    parameters: z10.object({
+      orderId: z10.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.cancelOrder(params.orderId);
@@ -4594,8 +4864,8 @@ function createGetOrderTrackingTool(client) {
   return {
     name: "acp_get_order_tracking",
     description: "Get shipping tracking information for an order.",
-    parameters: z8.object({
-      orderId: z8.string().describe("Order ID")
+    parameters: z10.object({
+      orderId: z10.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrderTracking(params.orderId);
@@ -5170,12 +5440,14 @@ var OpenAIWhisperProvider = class {
         text: verboseResponse.text,
         language: verboseResponse.language,
         duration: verboseResponse.duration,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         segments: verboseResponse.segments?.map((seg) => ({
           id: seg.id,
           start: seg.start,
           end: seg.end,
           text: seg.text
         })),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         words: verboseResponse.words?.map((word) => ({
           word: word.word,
           start: word.start,
@@ -5449,6 +5721,7 @@ var OpenAITTSProvider = class {
     try {
       const response = await this.client.audio.speech.create({
         model: config?.model || "tts-1",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         voice: config?.voice || "alloy",
         input: text,
         speed: config?.speed || 1,
@@ -5473,6 +5746,7 @@ var OpenAITTSProvider = class {
     try {
       const response = await this.client.audio.speech.create({
         model: config?.model || "tts-1",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         voice: config?.voice || "alloy",
         input: text,
         speed: config?.speed || 1,
@@ -5916,13 +6190,13 @@ var TenantManager = class {
   /**
    * Get tenant by ID
    */
-  async getTenant(tenantId) {
+  getTenant(tenantId) {
     return this.storage.getTenant(tenantId);
   }
   /**
    * Get tenant by slug
    */
-  async getTenantBySlug(slug) {
+  getTenantBySlug(slug) {
     return this.storage.getTenantBySlug(slug);
   }
   /**
@@ -6269,8 +6543,17 @@ export {
   VoiceType,
   Workflow,
   WorkflowFactory,
+  calculatorClient,
+  calculatorDef,
+  calculatorServer,
   calculatorTool,
+  clientTool,
   createACPTools,
+  createAnthropicProvider,
+  createGeminiProvider,
+  createOllamaProvider,
+  createOpenAIProvider,
+  createProvider,
   defaultLogger,
   figmaGetCommentsTool,
   figmaGetFileTool,
@@ -6283,12 +6566,17 @@ export {
   globalMetrics,
   globalTracer,
   httpRequestTool,
+  hybridTool,
   mcpToolToAgenticTool,
   n8nExecuteWorkflowTool,
   n8nGetExecutionTool,
   n8nGetWorkflowTool,
   n8nListWorkflowsTool,
   n8nTriggerWebhookTool,
+  serverTool,
   stringTransformTool,
-  textSummaryTool
+  textSummaryTool,
+  toLegacyTool,
+  toLegacyTools,
+  toolDefinition
 };