@lov3kaizen/agentsea-core 0.4.0 → 0.5.1

package/dist/index.js

@@ -95,7 +95,11 @@ __export(index_exports, {
   VoiceType: () => import_agentsea_types.VoiceType,
   Workflow: () => Workflow,
   WorkflowFactory: () => WorkflowFactory,
+  calculatorClient: () => calculatorClient,
+  calculatorDef: () => calculatorDef,
+  calculatorServer: () => calculatorServer,
   calculatorTool: () => calculatorTool,
+  clientTool: () => clientTool,
   createACPTools: () => createACPTools,
   createAnthropicProvider: () => createAnthropicProvider,
   createGeminiProvider: () => createGeminiProvider,
@@ -114,14 +118,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
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -383,6 +392,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") {
@@ -779,7 +789,7 @@ var httpRequestTool = {
     url: import_zod2.z.string().url().describe("The URL to make the request to"),
     method: import_zod2.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("GET").describe("HTTP method"),
     headers: import_zod2.z.record(import_zod2.z.string()).optional().describe("HTTP headers"),
-    body: import_zod2.z.any().optional().describe("Request body (for POST, PUT, PATCH)"),
+    body: import_zod2.z.unknown().optional().describe("Request body (for POST, PUT, PATCH)"),
     timeout: import_zod2.z.number().optional().default(1e4).describe("Request timeout in milliseconds")
   }),
   execute: async (params) => {
@@ -1237,7 +1247,7 @@ var n8nExecuteWorkflowTool = {
   description: "Execute an n8n workflow by ID or name. Optionally pass input data to the workflow.",
   parameters: import_zod6.z.object({
     workflowId: import_zod6.z.string().describe("The ID of the workflow to execute"),
-    data: import_zod6.z.any().optional().describe("Input data to pass to the workflow execution"),
+    data: import_zod6.z.unknown().optional().describe("Input data to pass to the workflow execution"),
     waitForCompletion: import_zod6.z.boolean().default(true).describe("Wait for workflow execution to complete before returning"),
     apiKey: import_zod6.z.string().optional().describe("n8n API key (or use N8N_API_KEY env var)"),
     baseUrl: import_zod6.z.string().optional().describe("n8n base URL (or use N8N_BASE_URL env var)")
@@ -1354,7 +1364,7 @@ var n8nTriggerWebhookTool = {
   parameters: import_zod6.z.object({
     webhookPath: import_zod6.z.string().describe('The webhook path (e.g., "webhook/my-workflow")'),
     method: import_zod6.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("POST").describe("HTTP method for the webhook"),
-    data: import_zod6.z.any().optional().describe("Data to send to the webhook"),
+    data: import_zod6.z.unknown().optional().describe("Data to send to the webhook"),
     headers: import_zod6.z.record(import_zod6.z.string()).optional().describe("Additional headers to include"),
     baseUrl: import_zod6.z.string().optional().describe("n8n base URL (or use N8N_BASE_URL env var)")
   }),
@@ -1445,6 +1455,162 @@ async function pollExecutionStatus(executionId, apiKey, baseUrl, maxAttempts = 3
   );
 }
 
+// src/tools/built-in/calculator.isomorphic.ts
+var import_zod8 = require("zod");
+
+// src/tools/tool-definition.ts
+var import_zod7 = require("zod");
+function toolDefinition(options) {
+  const {
+    name,
+    description,
+    inputSchema,
+    outputSchema = import_zod7.z.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 = import_zod8.z.object({
+  operation: import_zod8.z.enum(["add", "subtract", "multiply", "divide"]).describe("The arithmetic operation to perform"),
+  a: import_zod8.z.number().describe("First number"),
+  b: import_zod8.z.number().describe("Second number")
+});
+var calculatorOutputSchema = import_zod8.z.object({
+  result: import_zod8.z.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
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_zod_to_json_schema = require("zod-to-json-schema");
@@ -1471,6 +1637,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
@@ -1502,6 +1669,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
@@ -1565,6 +1733,7 @@ var AnthropicProvider = class {
               type: "tool_result",
               tool_use_id: message.toolCallId || "",
               content: message.content
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
             });
           }
         }
@@ -1822,8 +1991,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,
@@ -2013,7 +2183,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),
@@ -2027,6 +2197,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) {
@@ -2061,6 +2232,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);
@@ -3926,7 +4098,7 @@ var MCPClient = class extends import_events2.EventEmitter {
 };
 
 // src/mcp/tool-adapter.ts
-var import_zod7 = require("zod");
+var import_zod9 = require("zod");
 function mcpToolToAgenticTool(mcpTool, client) {
   const zodSchema = jsonSchemaToZod(mcpTool.inputSchema);
   return {
@@ -3934,7 +4106,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"}`
@@ -3958,26 +4133,30 @@ function jsonSchemaToZod(schema) {
       let zodType;
       switch (propSchema.type) {
         case "string":
-          zodType = import_zod7.z.string();
-          if (propSchema.description) {
+          zodType = import_zod9.z.string();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "number":
-          zodType = import_zod7.z.number();
-          if (propSchema.description) {
+          zodType = import_zod9.z.number();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "boolean":
-          zodType = import_zod7.z.boolean();
-          if (propSchema.description) {
+          zodType = import_zod9.z.boolean();
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
         case "array":
-          zodType = import_zod7.z.array(jsonSchemaToZod(propSchema.items || {}));
-          if (propSchema.description) {
+          zodType = import_zod9.z.array(
+            jsonSchemaToZod(
+              propSchema.items || {}
+            )
+          );
+          if (typeof propSchema.description === "string") {
             zodType = zodType.describe(propSchema.description);
           }
           break;
@@ -3985,16 +4164,17 @@ function jsonSchemaToZod(schema) {
           zodType = jsonSchemaToZod(propSchema);
           break;
         default:
-          zodType = import_zod7.z.any();
+          zodType = import_zod9.z.any();
       }
-      if (!schema.required?.includes(key)) {
+      const required = schema.required;
+      if (!required?.includes(key)) {
         zodType = zodType.optional();
       }
       shape[key] = zodType;
     }
-    return import_zod7.z.object(shape);
+    return import_zod9.z.object(shape);
   }
-  return import_zod7.z.any();
+  return import_zod9.z.any();
 }
 
 // src/mcp/registry.ts
@@ -4391,7 +4571,7 @@ var ACPClient = class {
 };
 
 // src/acp/tools.ts
-var import_zod8 = require("zod");
+var import_zod10 = require("zod");
 function createACPTools(client) {
   return [
     createSearchProductsTool(client),
@@ -4414,15 +4594,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: import_zod8.z.object({
-      query: import_zod8.z.string().optional().describe("Search query text"),
-      category: import_zod8.z.string().optional().describe("Product category filter"),
-      minPrice: import_zod8.z.number().optional().describe("Minimum price filter"),
-      maxPrice: import_zod8.z.number().optional().describe("Maximum price filter"),
-      limit: import_zod8.z.number().optional().default(10).describe("Maximum number of results"),
-      offset: import_zod8.z.number().optional().default(0).describe("Pagination offset"),
-      sortBy: import_zod8.z.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
-      sortOrder: import_zod8.z.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
+    parameters: import_zod10.z.object({
+      query: import_zod10.z.string().optional().describe("Search query text"),
+      category: import_zod10.z.string().optional().describe("Product category filter"),
+      minPrice: import_zod10.z.number().optional().describe("Minimum price filter"),
+      maxPrice: import_zod10.z.number().optional().describe("Maximum price filter"),
+      limit: import_zod10.z.number().optional().default(10).describe("Maximum number of results"),
+      offset: import_zod10.z.number().optional().default(0).describe("Pagination offset"),
+      sortBy: import_zod10.z.enum(["price", "name", "popularity", "newest"]).optional().describe("Sort field"),
+      sortOrder: import_zod10.z.enum(["asc", "desc"]).optional().default("asc").describe("Sort order")
     }),
     execute: async (params) => {
       const response = await client.searchProducts(params);
@@ -4441,8 +4621,8 @@ function createGetProductTool(client) {
   return {
     name: "acp_get_product",
     description: "Get detailed information about a specific product by its ID.",
-    parameters: import_zod8.z.object({
-      productId: import_zod8.z.string().describe("Product ID")
+    parameters: import_zod10.z.object({
+      productId: import_zod10.z.string().describe("Product ID")
     }),
     execute: async (params) => {
       const response = await client.getProduct(params.productId);
@@ -4457,7 +4637,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: import_zod8.z.object({}),
+    parameters: import_zod10.z.object({}),
     execute: async () => {
       const response = await client.createCart();
       if (response.error) {
@@ -4471,14 +4651,14 @@ function createAddToCartTool(client) {
   return {
     name: "acp_add_to_cart",
     description: "Add a product to the shopping cart with specified quantity.",
-    parameters: import_zod8.z.object({
-      cartId: import_zod8.z.string().describe("Cart ID"),
-      productId: import_zod8.z.string().describe("Product ID to add"),
-      variantId: import_zod8.z.string().optional().describe("Product variant ID"),
-      quantity: import_zod8.z.number().min(1).describe("Quantity to add"),
-      price: import_zod8.z.object({
-        amount: import_zod8.z.number().describe("Price amount"),
-        currency: import_zod8.z.string().describe("Currency code (e.g., USD, EUR)")
+    parameters: import_zod10.z.object({
+      cartId: import_zod10.z.string().describe("Cart ID"),
+      productId: import_zod10.z.string().describe("Product ID to add"),
+      variantId: import_zod10.z.string().optional().describe("Product variant ID"),
+      quantity: import_zod10.z.number().min(1).describe("Quantity to add"),
+      price: import_zod10.z.object({
+        amount: import_zod10.z.number().describe("Price amount"),
+        currency: import_zod10.z.string().describe("Currency code (e.g., USD, EUR)")
       }).describe("Product price")
     }),
     execute: async (params) => {
@@ -4501,10 +4681,10 @@ function createUpdateCartItemTool(client) {
   return {
     name: "acp_update_cart_item",
     description: "Update the quantity of an item in the shopping cart.",
-    parameters: import_zod8.z.object({
-      cartId: import_zod8.z.string().describe("Cart ID"),
-      productId: import_zod8.z.string().describe("Product ID to update"),
-      quantity: import_zod8.z.number().min(0).describe("New quantity (0 to remove)")
+    parameters: import_zod10.z.object({
+      cartId: import_zod10.z.string().describe("Cart ID"),
+      productId: import_zod10.z.string().describe("Product ID to update"),
+      quantity: import_zod10.z.number().min(0).describe("New quantity (0 to remove)")
     }),
     execute: async (params) => {
       const response = await client.updateCartItem(
@@ -4525,9 +4705,9 @@ function createRemoveFromCartTool(client) {
   return {
     name: "acp_remove_from_cart",
     description: "Remove a product from the shopping cart.",
-    parameters: import_zod8.z.object({
-      cartId: import_zod8.z.string().describe("Cart ID"),
-      productId: import_zod8.z.string().describe("Product ID to remove")
+    parameters: import_zod10.z.object({
+      cartId: import_zod10.z.string().describe("Cart ID"),
+      productId: import_zod10.z.string().describe("Product ID to remove")
     }),
     execute: async (params) => {
       const response = await client.removeFromCart(
@@ -4547,8 +4727,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: import_zod8.z.object({
-      cartId: import_zod8.z.string().describe("Cart ID")
+    parameters: import_zod10.z.object({
+      cartId: import_zod10.z.string().describe("Cart ID")
     }),
     execute: async (params) => {
       const response = await client.getCart(params.cartId);
@@ -4563,12 +4743,12 @@ function createCheckoutTool(client) {
   return {
     name: "acp_create_checkout",
     description: "Create a checkout session from a shopping cart to begin the purchase process.",
-    parameters: import_zod8.z.object({
-      cartId: import_zod8.z.string().describe("Cart ID"),
-      customer: import_zod8.z.object({
-        email: import_zod8.z.string().email().describe("Customer email"),
-        name: import_zod8.z.string().optional().describe("Customer name"),
-        phone: import_zod8.z.string().optional().describe("Customer phone number")
+    parameters: import_zod10.z.object({
+      cartId: import_zod10.z.string().describe("Cart ID"),
+      customer: import_zod10.z.object({
+        email: import_zod10.z.string().email().describe("Customer email"),
+        name: import_zod10.z.string().optional().describe("Customer name"),
+        phone: import_zod10.z.string().optional().describe("Customer phone number")
       }).optional().describe("Customer information")
     }),
     execute: async (params) => {
@@ -4589,15 +4769,15 @@ function createUpdateShippingAddressTool(client) {
   return {
     name: "acp_update_shipping_address",
     description: "Update the shipping address for a checkout session.",
-    parameters: import_zod8.z.object({
-      sessionId: import_zod8.z.string().describe("Checkout session ID"),
-      address: import_zod8.z.object({
-        line1: import_zod8.z.string().describe("Address line 1"),
-        line2: import_zod8.z.string().optional().describe("Address line 2"),
-        city: import_zod8.z.string().describe("City"),
-        state: import_zod8.z.string().optional().describe("State/Province"),
-        postalCode: import_zod8.z.string().describe("Postal/ZIP code"),
-        country: import_zod8.z.string().describe("Country code (e.g., US, GB)")
+    parameters: import_zod10.z.object({
+      sessionId: import_zod10.z.string().describe("Checkout session ID"),
+      address: import_zod10.z.object({
+        line1: import_zod10.z.string().describe("Address line 1"),
+        line2: import_zod10.z.string().optional().describe("Address line 2"),
+        city: import_zod10.z.string().describe("City"),
+        state: import_zod10.z.string().optional().describe("State/Province"),
+        postalCode: import_zod10.z.string().describe("Postal/ZIP code"),
+        country: import_zod10.z.string().describe("Country code (e.g., US, GB)")
       }).describe("Shipping address")
     }),
     execute: async (params) => {
@@ -4618,12 +4798,12 @@ function createUpdatePaymentMethodTool(client) {
   return {
     name: "acp_update_payment_method",
     description: "Update the payment method for a checkout session.",
-    parameters: import_zod8.z.object({
-      sessionId: import_zod8.z.string().describe("Checkout session ID"),
-      paymentMethod: import_zod8.z.object({
-        type: import_zod8.z.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
-        token: import_zod8.z.string().optional().describe("Payment token"),
-        delegatedProvider: import_zod8.z.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
+    parameters: import_zod10.z.object({
+      sessionId: import_zod10.z.string().describe("Checkout session ID"),
+      paymentMethod: import_zod10.z.object({
+        type: import_zod10.z.enum(["card", "delegated", "wallet", "bank_transfer"]).describe("Payment method type"),
+        token: import_zod10.z.string().optional().describe("Payment token"),
+        delegatedProvider: import_zod10.z.string().optional().describe("Delegated payment provider (e.g., stripe, paypal)")
       }).describe("Payment method details")
     }),
     execute: async (params) => {
@@ -4644,8 +4824,8 @@ function createCompleteCheckoutTool(client) {
   return {
     name: "acp_complete_checkout",
     description: "Complete the checkout process and create an order. This finalizes the purchase.",
-    parameters: import_zod8.z.object({
-      sessionId: import_zod8.z.string().describe("Checkout session ID")
+    parameters: import_zod10.z.object({
+      sessionId: import_zod10.z.string().describe("Checkout session ID")
     }),
     execute: async (params) => {
       const response = await client.completeCheckout(params.sessionId);
@@ -4662,8 +4842,8 @@ function createGetOrderTool(client) {
   return {
     name: "acp_get_order",
     description: "Get detailed information about an order by its ID.",
-    parameters: import_zod8.z.object({
-      orderId: import_zod8.z.string().describe("Order ID")
+    parameters: import_zod10.z.object({
+      orderId: import_zod10.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrder(params.orderId);
@@ -4678,8 +4858,8 @@ function createCancelOrderTool(client) {
   return {
     name: "acp_cancel_order",
     description: "Cancel an order. Only orders that have not been shipped can be cancelled.",
-    parameters: import_zod8.z.object({
-      orderId: import_zod8.z.string().describe("Order ID")
+    parameters: import_zod10.z.object({
+      orderId: import_zod10.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.cancelOrder(params.orderId);
@@ -4694,8 +4874,8 @@ function createGetOrderTrackingTool(client) {
   return {
     name: "acp_get_order_tracking",
     description: "Get shipping tracking information for an order.",
-    parameters: import_zod8.z.object({
-      orderId: import_zod8.z.string().describe("Order ID")
+    parameters: import_zod10.z.object({
+      orderId: import_zod10.z.string().describe("Order ID")
     }),
     execute: async (params) => {
       const response = await client.getOrderTracking(params.orderId);
@@ -5259,12 +5439,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,
@@ -5538,6 +5720,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,
@@ -5562,6 +5745,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,
@@ -5996,13 +6180,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);
   }
   /**
@@ -6350,7 +6534,11 @@ var MemoryTenantStorage = class {
   VoiceType,
   Workflow,
   WorkflowFactory,
+  calculatorClient,
+  calculatorDef,
+  calculatorServer,
   calculatorTool,
+  clientTool,
   createACPTools,
   createAnthropicProvider,
   createGeminiProvider,
@@ -6369,12 +6557,17 @@ var MemoryTenantStorage = class {
   globalMetrics,
   globalTracer,
   httpRequestTool,
+  hybridTool,
   mcpToolToAgenticTool,
   n8nExecuteWorkflowTool,
   n8nGetExecutionTool,
   n8nGetWorkflowTool,
   n8nListWorkflowsTool,
   n8nTriggerWebhookTool,
+  serverTool,
   stringTransformTool,
-  textSummaryTool
+  textSummaryTool,
+  toLegacyTool,
+  toLegacyTools,
+  toolDefinition
 });