@invect/core 0.0.1

package/dist/services/agent-tools/agent-tool-registry.cjs

@@ -0,0 +1,101 @@
+//#region src/services/agent-tools/agent-tool-registry.ts
+/**
+* Registry for agent tools
+*/
+var AgentToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	constructor(logger) {
+		this.logger = logger;
+	}
+	/**
+	* Register a tool with its executor
+	*/
+	register(definition, executor) {
+		if (this.tools.has(definition.id)) this.logger?.warn(`Tool '${definition.id}' is being overwritten`);
+		this.tools.set(definition.id, {
+			definition,
+			executor
+		});
+		this.logger?.debug(`Registered agent tool: ${definition.id}`);
+	}
+	/**
+	* Get a registered tool by ID
+	*/
+	get(toolId) {
+		return this.tools.get(toolId);
+	}
+	/**
+	* Get all registered tools
+	*/
+	getAll() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* Get tools by category
+	*/
+	getByCategory(category) {
+		return Array.from(this.tools.values()).filter((tool) => tool.definition.category === category);
+	}
+	/**
+	* Get only tool definitions (without executors)
+	*/
+	getDefinitions() {
+		return Array.from(this.tools.values()).map((tool) => tool.definition);
+	}
+	/**
+	* Get definitions for specific tool IDs
+	*/
+	getDefinitionsForIds(toolIds) {
+		return toolIds.map((id) => this.tools.get(id)?.definition).filter((def) => def !== void 0);
+	}
+	/**
+	* Check if a tool is registered
+	*/
+	has(toolId) {
+		return this.tools.has(toolId);
+	}
+	/**
+	* Get count of registered tools
+	*/
+	get size() {
+		return this.tools.size;
+	}
+	/**
+	* Get tools that are enabled by default
+	*/
+	getDefaultEnabled() {
+		return Array.from(this.tools.values()).filter((tool) => tool.definition.enabledByDefault);
+	}
+};
+let globalToolRegistry = null;
+/**
+* Get the global tool registry instance
+*/
+function getGlobalToolRegistry() {
+	if (!globalToolRegistry) throw new Error("Global tool registry not initialized. Call initializeGlobalToolRegistry() first.");
+	return globalToolRegistry;
+}
+/**
+* Set the global tool registry instance
+*/
+function setGlobalToolRegistry(registry) {
+	globalToolRegistry = registry;
+}
+/**
+* Initialize the global registry with tools from node executors and standalone tools
+*/
+async function initializeGlobalToolRegistry(logger) {
+	const registry = new AgentToolRegistry(logger);
+	const { registerStandaloneTools } = await Promise.resolve().then(() => require("./builtin/index.cjs"));
+	registerStandaloneTools(registry, logger);
+	setGlobalToolRegistry(registry);
+	logger?.info(`Agent tool registry initialized with ${registry.size} tools`);
+	return registry;
+}
+//#endregion
+exports.AgentToolRegistry = AgentToolRegistry;
+exports.getGlobalToolRegistry = getGlobalToolRegistry;
+exports.initializeGlobalToolRegistry = initializeGlobalToolRegistry;
+exports.setGlobalToolRegistry = setGlobalToolRegistry;
+
+//# sourceMappingURL=agent-tool-registry.cjs.map

package/dist/services/agent-tools/agent-tool-registry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool-registry.cjs","names":[],"sources":["../../../src/services/agent-tools/agent-tool-registry.ts"],"sourcesContent":["/**\n * Agent Tool Registry\n *\n * Registry for managing agent tools. Tools can be:\n * 1. Action-based (automatically registered from defineAction())\n * 2. Standalone (tools without corresponding nodes, like math_eval)\n * 3. Custom (user-defined via API)\n * 4. Flow-based (another flow as a tool)\n */\n\nimport { Logger } from 'src/types/schemas';\nimport {\n  AgentToolDefinition,\n  AgentToolExecutor,\n  RegisteredAgentTool,\n  AgentToolCategory,\n} from 'src/types/agent-tool.types';\n\n/**\n * Registry for agent tools\n */\nexport class AgentToolRegistry {\n  private tools = new Map<string, RegisteredAgentTool>();\n\n  constructor(private readonly logger?: Logger) {}\n\n  /**\n   * Register a tool with its executor\n   */\n  register(definition: AgentToolDefinition, executor: AgentToolExecutor): void {\n    if (this.tools.has(definition.id)) {\n      this.logger?.warn(`Tool '${definition.id}' is being overwritten`);\n    }\n\n    this.tools.set(definition.id, { definition, executor });\n    this.logger?.debug(`Registered agent tool: ${definition.id}`);\n  }\n\n  /**\n   * Get a registered tool by ID\n   */\n  get(toolId: string): RegisteredAgentTool | undefined {\n    return this.tools.get(toolId);\n  }\n\n  /**\n   * Get all registered tools\n   */\n  getAll(): RegisteredAgentTool[] {\n    return Array.from(this.tools.values());\n  }\n\n  /**\n   * Get tools by category\n   */\n  getByCategory(category: AgentToolCategory): RegisteredAgentTool[] {\n    return Array.from(this.tools.values()).filter((tool) => tool.definition.category === category);\n  }\n\n  /**\n   * Get only tool definitions (without executors)\n   */\n  getDefinitions(): AgentToolDefinition[] {\n    return Array.from(this.tools.values()).map((tool) => tool.definition);\n  }\n\n  /**\n   * Get definitions for specific tool IDs\n   */\n  getDefinitionsForIds(toolIds: string[]): AgentToolDefinition[] {\n    return toolIds\n      .map((id) => this.tools.get(id)?.definition)\n      .filter((def): def is AgentToolDefinition => def !== undefined);\n  }\n\n  /**\n   * Check if a tool is registered\n   */\n  has(toolId: string): boolean {\n    return this.tools.has(toolId);\n  }\n\n  /**\n   * Get count of registered tools\n   */\n  get size(): number {\n    return this.tools.size;\n  }\n\n  /**\n   * Get tools that are enabled by default\n   */\n  getDefaultEnabled(): RegisteredAgentTool[] {\n    return Array.from(this.tools.values()).filter((tool) => tool.definition.enabledByDefault);\n  }\n}\n\n// Global registry instance\nlet globalToolRegistry: AgentToolRegistry | null = null;\n\n/**\n * Get the global tool registry instance\n */\nexport function getGlobalToolRegistry(): AgentToolRegistry {\n  if (!globalToolRegistry) {\n    throw new Error(\n      'Global tool registry not initialized. Call initializeGlobalToolRegistry() first.',\n    );\n  }\n  return globalToolRegistry;\n}\n\n/**\n * Set the global tool registry instance\n */\nexport function setGlobalToolRegistry(registry: AgentToolRegistry): void {\n  globalToolRegistry = registry;\n}\n\n/**\n * Initialize the global registry with tools from node executors and standalone tools\n */\nexport async function initializeGlobalToolRegistry(logger?: Logger): Promise<AgentToolRegistry> {\n  const registry = new AgentToolRegistry(logger);\n\n  // Import and register standalone tools (tools without corresponding nodes)\n  const { registerStandaloneTools } = await import('./builtin');\n  registerStandaloneTools(registry, logger);\n\n  setGlobalToolRegistry(registry);\n  logger?.info(`Agent tool registry initialized with ${registry.size} tools`);\n\n  return registry;\n}\n\n/**\n * Reset the global tool registry\n */\nexport function resetGlobalToolRegistry(): void {\n  globalToolRegistry = null;\n}\n"],"mappings":";;;;AAqBA,IAAa,oBAAb,MAA+B;CAC7B,wBAAgB,IAAI,KAAkC;CAEtD,YAAY,QAAkC;AAAjB,OAAA,SAAA;;;;;CAK7B,SAAS,YAAiC,UAAmC;AAC3E,MAAI,KAAK,MAAM,IAAI,WAAW,GAAG,CAC/B,MAAK,QAAQ,KAAK,SAAS,WAAW,GAAG,wBAAwB;AAGnE,OAAK,MAAM,IAAI,WAAW,IAAI;GAAE;GAAY;GAAU,CAAC;AACvD,OAAK,QAAQ,MAAM,0BAA0B,WAAW,KAAK;;;;;CAM/D,IAAI,QAAiD;AACnD,SAAO,KAAK,MAAM,IAAI,OAAO;;;;;CAM/B,SAAgC;AAC9B,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC;;;;;CAMxC,cAAc,UAAoD;AAChE,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,QAAQ,SAAS,KAAK,WAAW,aAAa,SAAS;;;;;CAMhG,iBAAwC;AACtC,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,KAAK,SAAS,KAAK,WAAW;;;;;CAMvE,qBAAqB,SAA0C;AAC7D,SAAO,QACJ,KAAK,OAAO,KAAK,MAAM,IAAI,GAAG,EAAE,WAAW,CAC3C,QAAQ,QAAoC,QAAQ,KAAA,EAAU;;;;;CAMnE,IAAI,QAAyB;AAC3B,SAAO,KAAK,MAAM,IAAI,OAAO;;;;;CAM/B,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;CAMpB,oBAA2C;AACzC,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,QAAQ,SAAS,KAAK,WAAW,iBAAiB;;;AAK7F,IAAI,qBAA+C;;;;AAKnD,SAAgB,wBAA2C;AACzD,KAAI,CAAC,mBACH,OAAM,IAAI,MACR,mFACD;AAEH,QAAO;;;;;AAMT,SAAgB,sBAAsB,UAAmC;AACvE,sBAAqB;;;;;AAMvB,eAAsB,6BAA6B,QAA6C;CAC9F,MAAM,WAAW,IAAI,kBAAkB,OAAO;CAG9C,MAAM,EAAE,4BAA4B,MAAA,QAAA,SAAA,CAAA,WAAA,QAAM,sBAAA,CAAA;AAC1C,yBAAwB,UAAU,OAAO;AAEzC,uBAAsB,SAAS;AAC/B,SAAQ,KAAK,wCAAwC,SAAS,KAAK,QAAQ;AAE3E,QAAO"}

package/dist/services/agent-tools/agent-tool-registry.d.cts

@@ -0,0 +1,51 @@
+import { Logger } from "../../types/schemas-fresh/invect-config.cjs";
+import { AgentToolCategory, AgentToolDefinition, AgentToolExecutor, RegisteredAgentTool } from "../../types/agent-tool.types.cjs";
+
+//#region src/services/agent-tools/agent-tool-registry.d.ts
+/**
+ * Registry for agent tools
+ */
+declare class AgentToolRegistry {
+  private readonly logger?;
+  private tools;
+  constructor(logger?: Logger | undefined);
+  /**
+   * Register a tool with its executor
+   */
+  register(definition: AgentToolDefinition, executor: AgentToolExecutor): void;
+  /**
+   * Get a registered tool by ID
+   */
+  get(toolId: string): RegisteredAgentTool | undefined;
+  /**
+   * Get all registered tools
+   */
+  getAll(): RegisteredAgentTool[];
+  /**
+   * Get tools by category
+   */
+  getByCategory(category: AgentToolCategory): RegisteredAgentTool[];
+  /**
+   * Get only tool definitions (without executors)
+   */
+  getDefinitions(): AgentToolDefinition[];
+  /**
+   * Get definitions for specific tool IDs
+   */
+  getDefinitionsForIds(toolIds: string[]): AgentToolDefinition[];
+  /**
+   * Check if a tool is registered
+   */
+  has(toolId: string): boolean;
+  /**
+   * Get count of registered tools
+   */
+  get size(): number;
+  /**
+   * Get tools that are enabled by default
+   */
+  getDefaultEnabled(): RegisteredAgentTool[];
+}
+//#endregion
+export { AgentToolRegistry };
+//# sourceMappingURL=agent-tool-registry.d.cts.map

package/dist/services/agent-tools/agent-tool-registry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool-registry.d.cts","names":[],"sources":["../../../src/services/agent-tools/agent-tool-registry.ts"],"mappings":";;;;;;;cAqBa,iBAAA;EAAA,iBAGkB,MAAA;EAAA,QAFrB,KAAA;cAEqB,MAAA,GAAS,MAAA;EAoEE;;;EA/DxC,QAAA,CAAS,UAAA,EAAY,mBAAA,EAAqB,QAAA,EAAU,iBAAA;EALd;;;EAiBtC,GAAA,CAAI,MAAA,WAAiB,mBAAA;EAZZ;;;EAmBT,MAAA,CAAA,GAAU,mBAAA;EAPN;;;EAcJ,aAAA,CAAc,QAAA,EAAU,iBAAA,GAAoB,mBAAA;EAA5C;;;EAOA,cAAA,CAAA,GAAkB,mBAAA;EAAlB;;;EAOA,oBAAA,CAAqB,OAAA,aAAoB,mBAAA;EAAA;;;EASzC,GAAA,CAAI,MAAA;EAcJ;;;EAAA,IAPI,IAAA,CAAA;;;;EAOJ,iBAAA,CAAA,GAAqB,mBAAA;AAAA"}

package/dist/services/agent-tools/agent-tool-registry.d.ts

@@ -0,0 +1,51 @@
+import { Logger } from "../../types/schemas-fresh/invect-config.js";
+import { AgentToolCategory, AgentToolDefinition, AgentToolExecutor, RegisteredAgentTool } from "../../types/agent-tool.types.js";
+
+//#region src/services/agent-tools/agent-tool-registry.d.ts
+/**
+ * Registry for agent tools
+ */
+declare class AgentToolRegistry {
+  private readonly logger?;
+  private tools;
+  constructor(logger?: Logger | undefined);
+  /**
+   * Register a tool with its executor
+   */
+  register(definition: AgentToolDefinition, executor: AgentToolExecutor): void;
+  /**
+   * Get a registered tool by ID
+   */
+  get(toolId: string): RegisteredAgentTool | undefined;
+  /**
+   * Get all registered tools
+   */
+  getAll(): RegisteredAgentTool[];
+  /**
+   * Get tools by category
+   */
+  getByCategory(category: AgentToolCategory): RegisteredAgentTool[];
+  /**
+   * Get only tool definitions (without executors)
+   */
+  getDefinitions(): AgentToolDefinition[];
+  /**
+   * Get definitions for specific tool IDs
+   */
+  getDefinitionsForIds(toolIds: string[]): AgentToolDefinition[];
+  /**
+   * Check if a tool is registered
+   */
+  has(toolId: string): boolean;
+  /**
+   * Get count of registered tools
+   */
+  get size(): number;
+  /**
+   * Get tools that are enabled by default
+   */
+  getDefaultEnabled(): RegisteredAgentTool[];
+}
+//#endregion
+export { AgentToolRegistry };
+//# sourceMappingURL=agent-tool-registry.d.ts.map

package/dist/services/agent-tools/agent-tool-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool-registry.d.ts","names":[],"sources":["../../../src/services/agent-tools/agent-tool-registry.ts"],"mappings":";;;;;;;cAqBa,iBAAA;EAAA,iBAGkB,MAAA;EAAA,QAFrB,KAAA;cAEqB,MAAA,GAAS,MAAA;EAoEE;;;EA/DxC,QAAA,CAAS,UAAA,EAAY,mBAAA,EAAqB,QAAA,EAAU,iBAAA;;;;EAYpD,GAAA,CAAI,MAAA,WAAiB,mBAAA;EAZA;;;EAmBrB,MAAA,CAAA,GAAU,mBAAA;EAPV;;;EAcA,aAAA,CAAc,QAAA,EAAU,iBAAA,GAAoB,mBAAA;EAPlC;;;EAcV,cAAA,CAAA,GAAkB,mBAAA;EAP0B;;;EAc5C,oBAAA,CAAqB,OAAA,aAAoB,mBAAA;EAApB;;;EASrB,GAAA,CAAI,MAAA;EAOA;;;EAAA,IAAA,IAAA,CAAA;EAOoC;;;EAAxC,iBAAA,CAAA,GAAqB,mBAAA;AAAA"}

package/dist/services/agent-tools/agent-tool-registry.js

@@ -0,0 +1,98 @@
+//#region src/services/agent-tools/agent-tool-registry.ts
+/**
+* Registry for agent tools
+*/
+var AgentToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	constructor(logger) {
+		this.logger = logger;
+	}
+	/**
+	* Register a tool with its executor
+	*/
+	register(definition, executor) {
+		if (this.tools.has(definition.id)) this.logger?.warn(`Tool '${definition.id}' is being overwritten`);
+		this.tools.set(definition.id, {
+			definition,
+			executor
+		});
+		this.logger?.debug(`Registered agent tool: ${definition.id}`);
+	}
+	/**
+	* Get a registered tool by ID
+	*/
+	get(toolId) {
+		return this.tools.get(toolId);
+	}
+	/**
+	* Get all registered tools
+	*/
+	getAll() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* Get tools by category
+	*/
+	getByCategory(category) {
+		return Array.from(this.tools.values()).filter((tool) => tool.definition.category === category);
+	}
+	/**
+	* Get only tool definitions (without executors)
+	*/
+	getDefinitions() {
+		return Array.from(this.tools.values()).map((tool) => tool.definition);
+	}
+	/**
+	* Get definitions for specific tool IDs
+	*/
+	getDefinitionsForIds(toolIds) {
+		return toolIds.map((id) => this.tools.get(id)?.definition).filter((def) => def !== void 0);
+	}
+	/**
+	* Check if a tool is registered
+	*/
+	has(toolId) {
+		return this.tools.has(toolId);
+	}
+	/**
+	* Get count of registered tools
+	*/
+	get size() {
+		return this.tools.size;
+	}
+	/**
+	* Get tools that are enabled by default
+	*/
+	getDefaultEnabled() {
+		return Array.from(this.tools.values()).filter((tool) => tool.definition.enabledByDefault);
+	}
+};
+let globalToolRegistry = null;
+/**
+* Get the global tool registry instance
+*/
+function getGlobalToolRegistry() {
+	if (!globalToolRegistry) throw new Error("Global tool registry not initialized. Call initializeGlobalToolRegistry() first.");
+	return globalToolRegistry;
+}
+/**
+* Set the global tool registry instance
+*/
+function setGlobalToolRegistry(registry) {
+	globalToolRegistry = registry;
+}
+/**
+* Initialize the global registry with tools from node executors and standalone tools
+*/
+async function initializeGlobalToolRegistry(logger) {
+	const registry = new AgentToolRegistry(logger);
+	const { registerStandaloneTools } = await import("./builtin/index.js");
+	registerStandaloneTools(registry, logger);
+	setGlobalToolRegistry(registry);
+	logger?.info(`Agent tool registry initialized with ${registry.size} tools`);
+	return registry;
+}
+//#endregion
+export { AgentToolRegistry, getGlobalToolRegistry, initializeGlobalToolRegistry, setGlobalToolRegistry };
+
+//# sourceMappingURL=agent-tool-registry.js.map

package/dist/services/agent-tools/agent-tool-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool-registry.js","names":[],"sources":["../../../src/services/agent-tools/agent-tool-registry.ts"],"sourcesContent":["/**\n * Agent Tool Registry\n *\n * Registry for managing agent tools. Tools can be:\n * 1. Action-based (automatically registered from defineAction())\n * 2. Standalone (tools without corresponding nodes, like math_eval)\n * 3. Custom (user-defined via API)\n * 4. Flow-based (another flow as a tool)\n */\n\nimport { Logger } from 'src/types/schemas';\nimport {\n  AgentToolDefinition,\n  AgentToolExecutor,\n  RegisteredAgentTool,\n  AgentToolCategory,\n} from 'src/types/agent-tool.types';\n\n/**\n * Registry for agent tools\n */\nexport class AgentToolRegistry {\n  private tools = new Map<string, RegisteredAgentTool>();\n\n  constructor(private readonly logger?: Logger) {}\n\n  /**\n   * Register a tool with its executor\n   */\n  register(definition: AgentToolDefinition, executor: AgentToolExecutor): void {\n    if (this.tools.has(definition.id)) {\n      this.logger?.warn(`Tool '${definition.id}' is being overwritten`);\n    }\n\n    this.tools.set(definition.id, { definition, executor });\n    this.logger?.debug(`Registered agent tool: ${definition.id}`);\n  }\n\n  /**\n   * Get a registered tool by ID\n   */\n  get(toolId: string): RegisteredAgentTool | undefined {\n    return this.tools.get(toolId);\n  }\n\n  /**\n   * Get all registered tools\n   */\n  getAll(): RegisteredAgentTool[] {\n    return Array.from(this.tools.values());\n  }\n\n  /**\n   * Get tools by category\n   */\n  getByCategory(category: AgentToolCategory): RegisteredAgentTool[] {\n    return Array.from(this.tools.values()).filter((tool) => tool.definition.category === category);\n  }\n\n  /**\n   * Get only tool definitions (without executors)\n   */\n  getDefinitions(): AgentToolDefinition[] {\n    return Array.from(this.tools.values()).map((tool) => tool.definition);\n  }\n\n  /**\n   * Get definitions for specific tool IDs\n   */\n  getDefinitionsForIds(toolIds: string[]): AgentToolDefinition[] {\n    return toolIds\n      .map((id) => this.tools.get(id)?.definition)\n      .filter((def): def is AgentToolDefinition => def !== undefined);\n  }\n\n  /**\n   * Check if a tool is registered\n   */\n  has(toolId: string): boolean {\n    return this.tools.has(toolId);\n  }\n\n  /**\n   * Get count of registered tools\n   */\n  get size(): number {\n    return this.tools.size;\n  }\n\n  /**\n   * Get tools that are enabled by default\n   */\n  getDefaultEnabled(): RegisteredAgentTool[] {\n    return Array.from(this.tools.values()).filter((tool) => tool.definition.enabledByDefault);\n  }\n}\n\n// Global registry instance\nlet globalToolRegistry: AgentToolRegistry | null = null;\n\n/**\n * Get the global tool registry instance\n */\nexport function getGlobalToolRegistry(): AgentToolRegistry {\n  if (!globalToolRegistry) {\n    throw new Error(\n      'Global tool registry not initialized. Call initializeGlobalToolRegistry() first.',\n    );\n  }\n  return globalToolRegistry;\n}\n\n/**\n * Set the global tool registry instance\n */\nexport function setGlobalToolRegistry(registry: AgentToolRegistry): void {\n  globalToolRegistry = registry;\n}\n\n/**\n * Initialize the global registry with tools from node executors and standalone tools\n */\nexport async function initializeGlobalToolRegistry(logger?: Logger): Promise<AgentToolRegistry> {\n  const registry = new AgentToolRegistry(logger);\n\n  // Import and register standalone tools (tools without corresponding nodes)\n  const { registerStandaloneTools } = await import('./builtin');\n  registerStandaloneTools(registry, logger);\n\n  setGlobalToolRegistry(registry);\n  logger?.info(`Agent tool registry initialized with ${registry.size} tools`);\n\n  return registry;\n}\n\n/**\n * Reset the global tool registry\n */\nexport function resetGlobalToolRegistry(): void {\n  globalToolRegistry = null;\n}\n"],"mappings":";;;;AAqBA,IAAa,oBAAb,MAA+B;CAC7B,wBAAgB,IAAI,KAAkC;CAEtD,YAAY,QAAkC;AAAjB,OAAA,SAAA;;;;;CAK7B,SAAS,YAAiC,UAAmC;AAC3E,MAAI,KAAK,MAAM,IAAI,WAAW,GAAG,CAC/B,MAAK,QAAQ,KAAK,SAAS,WAAW,GAAG,wBAAwB;AAGnE,OAAK,MAAM,IAAI,WAAW,IAAI;GAAE;GAAY;GAAU,CAAC;AACvD,OAAK,QAAQ,MAAM,0BAA0B,WAAW,KAAK;;;;;CAM/D,IAAI,QAAiD;AACnD,SAAO,KAAK,MAAM,IAAI,OAAO;;;;;CAM/B,SAAgC;AAC9B,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC;;;;;CAMxC,cAAc,UAAoD;AAChE,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,QAAQ,SAAS,KAAK,WAAW,aAAa,SAAS;;;;;CAMhG,iBAAwC;AACtC,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,KAAK,SAAS,KAAK,WAAW;;;;;CAMvE,qBAAqB,SAA0C;AAC7D,SAAO,QACJ,KAAK,OAAO,KAAK,MAAM,IAAI,GAAG,EAAE,WAAW,CAC3C,QAAQ,QAAoC,QAAQ,KAAA,EAAU;;;;;CAMnE,IAAI,QAAyB;AAC3B,SAAO,KAAK,MAAM,IAAI,OAAO;;;;;CAM/B,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;CAMpB,oBAA2C;AACzC,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,QAAQ,SAAS,KAAK,WAAW,iBAAiB;;;AAK7F,IAAI,qBAA+C;;;;AAKnD,SAAgB,wBAA2C;AACzD,KAAI,CAAC,mBACH,OAAM,IAAI,MACR,mFACD;AAEH,QAAO;;;;;AAMT,SAAgB,sBAAsB,UAAmC;AACvE,sBAAqB;;;;;AAMvB,eAAsB,6BAA6B,QAA6C;CAC9F,MAAM,WAAW,IAAI,kBAAkB,OAAO;CAG9C,MAAM,EAAE,4BAA4B,MAAM,OAAO;AACjD,yBAAwB,UAAU,OAAO;AAEzC,uBAAsB,SAAS;AAC/B,SAAQ,KAAK,wCAAwC,SAAS,KAAK,QAAQ;AAE3E,QAAO"}

package/dist/services/agent-tools/builtin/index.cjs

@@ -0,0 +1,17 @@
+const require_math_tool = require("./math-tool.cjs");
+const require_json_logic_tool = require("./json-logic-tool.cjs");
+//#region src/services/agent-tools/builtin/index.ts
+/**
+* Register standalone tools (tools without corresponding nodes)
+*/
+function registerStandaloneTools(registry, logger) {
+	registry.register(require_math_tool.mathToolDefinition, require_math_tool.mathToolExecutor);
+	logger?.debug("Registered standalone tool: math_eval");
+	registry.register(require_json_logic_tool.jsonLogicToolDefinition, require_json_logic_tool.jsonLogicToolExecutor);
+	logger?.debug("Registered standalone tool: json_logic");
+	logger?.info(`Registered 2 standalone agent tools`);
+}
+//#endregion
+exports.registerStandaloneTools = registerStandaloneTools;
+
+//# sourceMappingURL=index.cjs.map

package/dist/services/agent-tools/builtin/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["mathToolDefinition","mathToolExecutor","jsonLogicToolDefinition","jsonLogicToolExecutor"],"sources":["../../../../src/services/agent-tools/builtin/index.ts"],"sourcesContent":["/**\n * Standalone Agent Tools\n *\n * These are tools that don't have a corresponding node executor.\n * Node-based tools (JQ, HTTP Request, Gmail) are registered automatically\n * from their node executors via AgentToolCapable interface.\n */\n\nimport { Logger } from 'src/types/schemas';\nimport { AgentToolRegistry } from '../agent-tool-registry';\nimport { mathToolDefinition, mathToolExecutor } from './math-tool';\nimport { jsonLogicToolDefinition, jsonLogicToolExecutor } from './json-logic-tool';\n\n/**\n * Register standalone tools (tools without corresponding nodes)\n */\nexport function registerStandaloneTools(registry: AgentToolRegistry, logger?: Logger): void {\n  // Math evaluation tool - standalone utility\n  registry.register(mathToolDefinition, mathToolExecutor);\n  logger?.debug('Registered standalone tool: math_eval');\n\n  // JSON Logic tool - standalone utility (used internally by If-Else node)\n  registry.register(jsonLogicToolDefinition, jsonLogicToolExecutor);\n  logger?.debug('Registered standalone tool: json_logic');\n\n  logger?.info(`Registered ${2} standalone agent tools`);\n}\n\n// Re-export standalone tools for direct use\nexport { mathToolDefinition, mathToolExecutor, jsonLogicToolDefinition, jsonLogicToolExecutor };\n"],"mappings":";;;;;;AAgBA,SAAgB,wBAAwB,UAA6B,QAAuB;AAE1F,UAAS,SAASA,kBAAAA,oBAAoBC,kBAAAA,iBAAiB;AACvD,SAAQ,MAAM,wCAAwC;AAGtD,UAAS,SAASC,wBAAAA,yBAAyBC,wBAAAA,sBAAsB;AACjE,SAAQ,MAAM,yCAAyC;AAEvD,SAAQ,KAAK,sCAAyC"}

package/dist/services/agent-tools/builtin/index.js

@@ -0,0 +1,17 @@
+import { mathToolDefinition, mathToolExecutor } from "./math-tool.js";
+import { jsonLogicToolDefinition, jsonLogicToolExecutor } from "./json-logic-tool.js";
+//#region src/services/agent-tools/builtin/index.ts
+/**
+* Register standalone tools (tools without corresponding nodes)
+*/
+function registerStandaloneTools(registry, logger) {
+	registry.register(mathToolDefinition, mathToolExecutor);
+	logger?.debug("Registered standalone tool: math_eval");
+	registry.register(jsonLogicToolDefinition, jsonLogicToolExecutor);
+	logger?.debug("Registered standalone tool: json_logic");
+	logger?.info(`Registered 2 standalone agent tools`);
+}
+//#endregion
+export { registerStandaloneTools };
+
+//# sourceMappingURL=index.js.map

package/dist/services/agent-tools/builtin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/services/agent-tools/builtin/index.ts"],"sourcesContent":["/**\n * Standalone Agent Tools\n *\n * These are tools that don't have a corresponding node executor.\n * Node-based tools (JQ, HTTP Request, Gmail) are registered automatically\n * from their node executors via AgentToolCapable interface.\n */\n\nimport { Logger } from 'src/types/schemas';\nimport { AgentToolRegistry } from '../agent-tool-registry';\nimport { mathToolDefinition, mathToolExecutor } from './math-tool';\nimport { jsonLogicToolDefinition, jsonLogicToolExecutor } from './json-logic-tool';\n\n/**\n * Register standalone tools (tools without corresponding nodes)\n */\nexport function registerStandaloneTools(registry: AgentToolRegistry, logger?: Logger): void {\n  // Math evaluation tool - standalone utility\n  registry.register(mathToolDefinition, mathToolExecutor);\n  logger?.debug('Registered standalone tool: math_eval');\n\n  // JSON Logic tool - standalone utility (used internally by If-Else node)\n  registry.register(jsonLogicToolDefinition, jsonLogicToolExecutor);\n  logger?.debug('Registered standalone tool: json_logic');\n\n  logger?.info(`Registered ${2} standalone agent tools`);\n}\n\n// Re-export standalone tools for direct use\nexport { mathToolDefinition, mathToolExecutor, jsonLogicToolDefinition, jsonLogicToolExecutor };\n"],"mappings":";;;;;;AAgBA,SAAgB,wBAAwB,UAA6B,QAAuB;AAE1F,UAAS,SAAS,oBAAoB,iBAAiB;AACvD,SAAQ,MAAM,wCAAwC;AAGtD,UAAS,SAAS,yBAAyB,sBAAsB;AACjE,SAAQ,MAAM,yCAAyC;AAEvD,SAAQ,KAAK,sCAAyC"}

package/dist/services/agent-tools/builtin/json-logic-tool.cjs

@@ -0,0 +1,73 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+let json_logic_js = require("json-logic-js");
+json_logic_js = require_runtime.__toESM(json_logic_js);
+//#region src/services/agent-tools/builtin/json-logic-tool.ts
+/**
+* JSON Logic Tool
+*
+* Agent tool for evaluating JSON Logic expressions.
+* Self-contained implementation using json-logic-js directly.
+*/
+const jsonLogicToolDefinition = {
+	id: "json_logic",
+	name: "JSON Logic",
+	description: "Evaluate conditional logic using JSON Logic rules. Use this for complex conditional checks, data validation, or rule-based decisions. Supports operators like ==, !=, <, >, <=, >=, and, or, not, if, in, cat, var, etc.",
+	inputSchema: {
+		type: "object",
+		properties: {
+			rule: {
+				type: "object",
+				description: "The JSON Logic rule to evaluate. Examples: {\"==\": [{\"var\": \"age\"}, 18]}, {\"and\": [{\">=\": [{\"var\": \"score\"}, 80]}, {\"var\": \"passed\"}]}"
+			},
+			data: {
+				type: "object",
+				description: "The data object to evaluate the rule against. Example: {\"age\": 25, \"score\": 85, \"passed\": true}"
+			}
+		},
+		required: ["rule", "data"],
+		additionalProperties: false
+	},
+	category: "utility",
+	tags: [
+		"logic",
+		"conditional",
+		"rules"
+	],
+	enabledByDefault: true
+};
+const jsonLogicToolExecutor = async (input, context) => {
+	const { logger } = context;
+	try {
+		const rule = input.rule;
+		const data = input.data;
+		if (!rule || typeof rule !== "object") return {
+			success: false,
+			error: "Rule must be a JSON Logic object"
+		};
+		if (!data || typeof data !== "object") return {
+			success: false,
+			error: "Data must be an object"
+		};
+		logger.debug("Executing JSON Logic tool", {
+			rule: JSON.stringify(rule).substring(0, 100),
+			dataKeys: Object.keys(data)
+		});
+		const result = json_logic_js.default.apply(rule, data);
+		return {
+			success: true,
+			output: Boolean(result)
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("JSON Logic tool execution failed", { error: errorMessage });
+		return {
+			success: false,
+			error: `JSON Logic evaluation failed: ${errorMessage}`
+		};
+	}
+};
+//#endregion
+exports.jsonLogicToolDefinition = jsonLogicToolDefinition;
+exports.jsonLogicToolExecutor = jsonLogicToolExecutor;
+
+//# sourceMappingURL=json-logic-tool.cjs.map

package/dist/services/agent-tools/builtin/json-logic-tool.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-logic-tool.cjs","names":["jsonLogic"],"sources":["../../../../src/services/agent-tools/builtin/json-logic-tool.ts"],"sourcesContent":["/**\n * JSON Logic Tool\n *\n * Agent tool for evaluating JSON Logic expressions.\n * Self-contained implementation using json-logic-js directly.\n */\n\nimport jsonLogic from 'json-logic-js';\nimport {\n  AgentToolDefinition,\n  AgentToolExecutor,\n  AgentToolResult,\n} from 'src/types/agent-tool.types';\n\nexport const jsonLogicToolDefinition: AgentToolDefinition = {\n  id: 'json_logic',\n  name: 'JSON Logic',\n  description:\n    'Evaluate conditional logic using JSON Logic rules. Use this for complex conditional checks, data validation, or rule-based decisions. Supports operators like ==, !=, <, >, <=, >=, and, or, not, if, in, cat, var, etc.',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      rule: {\n        type: 'object',\n        description:\n          'The JSON Logic rule to evaluate. Examples: {\"==\": [{\"var\": \"age\"}, 18]}, {\"and\": [{\">=\": [{\"var\": \"score\"}, 80]}, {\"var\": \"passed\"}]}',\n      },\n      data: {\n        type: 'object',\n        description:\n          'The data object to evaluate the rule against. Example: {\"age\": 25, \"score\": 85, \"passed\": true}',\n      },\n    },\n    required: ['rule', 'data'],\n    additionalProperties: false,\n  },\n  category: 'utility',\n  tags: ['logic', 'conditional', 'rules'],\n  enabledByDefault: true,\n};\n\nexport const jsonLogicToolExecutor: AgentToolExecutor = async (\n  input,\n  context,\n): Promise<AgentToolResult> => {\n  const { logger } = context;\n\n  try {\n    const rule = input.rule as Record<string, unknown>;\n    const data = input.data as object;\n\n    if (!rule || typeof rule !== 'object') {\n      return {\n        success: false,\n        error: 'Rule must be a JSON Logic object',\n      };\n    }\n\n    if (!data || typeof data !== 'object') {\n      return {\n        success: false,\n        error: 'Data must be an object',\n      };\n    }\n\n    logger.debug('Executing JSON Logic tool', {\n      rule: JSON.stringify(rule).substring(0, 100),\n      dataKeys: Object.keys(data),\n    });\n\n    // Use json-logic-js directly - no context function needed\n    const result = jsonLogic.apply(rule, data);\n\n    return {\n      success: true,\n      output: Boolean(result),\n    };\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    logger.error('JSON Logic tool execution failed', { error: errorMessage });\n    return {\n      success: false,\n      error: `JSON Logic evaluation failed: ${errorMessage}`,\n    };\n  }\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAa,0BAA+C;CAC1D,IAAI;CACJ,MAAM;CACN,aACE;CACF,aAAa;EACX,MAAM;EACN,YAAY;GACV,MAAM;IACJ,MAAM;IACN,aACE;IACH;GACD,MAAM;IACJ,MAAM;IACN,aACE;IACH;GACF;EACD,UAAU,CAAC,QAAQ,OAAO;EAC1B,sBAAsB;EACvB;CACD,UAAU;CACV,MAAM;EAAC;EAAS;EAAe;EAAQ;CACvC,kBAAkB;CACnB;AAED,MAAa,wBAA2C,OACtD,OACA,YAC6B;CAC7B,MAAM,EAAE,WAAW;AAEnB,KAAI;EACF,MAAM,OAAO,MAAM;EACnB,MAAM,OAAO,MAAM;AAEnB,MAAI,CAAC,QAAQ,OAAO,SAAS,SAC3B,QAAO;GACL,SAAS;GACT,OAAO;GACR;AAGH,MAAI,CAAC,QAAQ,OAAO,SAAS,SAC3B,QAAO;GACL,SAAS;GACT,OAAO;GACR;AAGH,SAAO,MAAM,6BAA6B;GACxC,MAAM,KAAK,UAAU,KAAK,CAAC,UAAU,GAAG,IAAI;GAC5C,UAAU,OAAO,KAAK,KAAK;GAC5B,CAAC;EAGF,MAAM,SAASA,cAAAA,QAAU,MAAM,MAAM,KAAK;AAE1C,SAAO;GACL,SAAS;GACT,QAAQ,QAAQ,OAAO;GACxB;UACM,OAAO;EACd,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO,MAAM,oCAAoC,EAAE,OAAO,cAAc,CAAC;AACzE,SAAO;GACL,SAAS;GACT,OAAO,iCAAiC;GACzC"}

package/dist/services/agent-tools/builtin/json-logic-tool.js

@@ -0,0 +1,70 @@
+import jsonLogic from "json-logic-js";
+//#region src/services/agent-tools/builtin/json-logic-tool.ts
+/**
+* JSON Logic Tool
+*
+* Agent tool for evaluating JSON Logic expressions.
+* Self-contained implementation using json-logic-js directly.
+*/
+const jsonLogicToolDefinition = {
+	id: "json_logic",
+	name: "JSON Logic",
+	description: "Evaluate conditional logic using JSON Logic rules. Use this for complex conditional checks, data validation, or rule-based decisions. Supports operators like ==, !=, <, >, <=, >=, and, or, not, if, in, cat, var, etc.",
+	inputSchema: {
+		type: "object",
+		properties: {
+			rule: {
+				type: "object",
+				description: "The JSON Logic rule to evaluate. Examples: {\"==\": [{\"var\": \"age\"}, 18]}, {\"and\": [{\">=\": [{\"var\": \"score\"}, 80]}, {\"var\": \"passed\"}]}"
+			},
+			data: {
+				type: "object",
+				description: "The data object to evaluate the rule against. Example: {\"age\": 25, \"score\": 85, \"passed\": true}"
+			}
+		},
+		required: ["rule", "data"],
+		additionalProperties: false
+	},
+	category: "utility",
+	tags: [
+		"logic",
+		"conditional",
+		"rules"
+	],
+	enabledByDefault: true
+};
+const jsonLogicToolExecutor = async (input, context) => {
+	const { logger } = context;
+	try {
+		const rule = input.rule;
+		const data = input.data;
+		if (!rule || typeof rule !== "object") return {
+			success: false,
+			error: "Rule must be a JSON Logic object"
+		};
+		if (!data || typeof data !== "object") return {
+			success: false,
+			error: "Data must be an object"
+		};
+		logger.debug("Executing JSON Logic tool", {
+			rule: JSON.stringify(rule).substring(0, 100),
+			dataKeys: Object.keys(data)
+		});
+		const result = jsonLogic.apply(rule, data);
+		return {
+			success: true,
+			output: Boolean(result)
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("JSON Logic tool execution failed", { error: errorMessage });
+		return {
+			success: false,
+			error: `JSON Logic evaluation failed: ${errorMessage}`
+		};
+	}
+};
+//#endregion
+export { jsonLogicToolDefinition, jsonLogicToolExecutor };
+
+//# sourceMappingURL=json-logic-tool.js.map

package/dist/services/agent-tools/builtin/json-logic-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-logic-tool.js","names":[],"sources":["../../../../src/services/agent-tools/builtin/json-logic-tool.ts"],"sourcesContent":["/**\n * JSON Logic Tool\n *\n * Agent tool for evaluating JSON Logic expressions.\n * Self-contained implementation using json-logic-js directly.\n */\n\nimport jsonLogic from 'json-logic-js';\nimport {\n  AgentToolDefinition,\n  AgentToolExecutor,\n  AgentToolResult,\n} from 'src/types/agent-tool.types';\n\nexport const jsonLogicToolDefinition: AgentToolDefinition = {\n  id: 'json_logic',\n  name: 'JSON Logic',\n  description:\n    'Evaluate conditional logic using JSON Logic rules. Use this for complex conditional checks, data validation, or rule-based decisions. Supports operators like ==, !=, <, >, <=, >=, and, or, not, if, in, cat, var, etc.',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      rule: {\n        type: 'object',\n        description:\n          'The JSON Logic rule to evaluate. Examples: {\"==\": [{\"var\": \"age\"}, 18]}, {\"and\": [{\">=\": [{\"var\": \"score\"}, 80]}, {\"var\": \"passed\"}]}',\n      },\n      data: {\n        type: 'object',\n        description:\n          'The data object to evaluate the rule against. Example: {\"age\": 25, \"score\": 85, \"passed\": true}',\n      },\n    },\n    required: ['rule', 'data'],\n    additionalProperties: false,\n  },\n  category: 'utility',\n  tags: ['logic', 'conditional', 'rules'],\n  enabledByDefault: true,\n};\n\nexport const jsonLogicToolExecutor: AgentToolExecutor = async (\n  input,\n  context,\n): Promise<AgentToolResult> => {\n  const { logger } = context;\n\n  try {\n    const rule = input.rule as Record<string, unknown>;\n    const data = input.data as object;\n\n    if (!rule || typeof rule !== 'object') {\n      return {\n        success: false,\n        error: 'Rule must be a JSON Logic object',\n      };\n    }\n\n    if (!data || typeof data !== 'object') {\n      return {\n        success: false,\n        error: 'Data must be an object',\n      };\n    }\n\n    logger.debug('Executing JSON Logic tool', {\n      rule: JSON.stringify(rule).substring(0, 100),\n      dataKeys: Object.keys(data),\n    });\n\n    // Use json-logic-js directly - no context function needed\n    const result = jsonLogic.apply(rule, data);\n\n    return {\n      success: true,\n      output: Boolean(result),\n    };\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    logger.error('JSON Logic tool execution failed', { error: errorMessage });\n    return {\n      success: false,\n      error: `JSON Logic evaluation failed: ${errorMessage}`,\n    };\n  }\n};\n"],"mappings":";;;;;;;;AAcA,MAAa,0BAA+C;CAC1D,IAAI;CACJ,MAAM;CACN,aACE;CACF,aAAa;EACX,MAAM;EACN,YAAY;GACV,MAAM;IACJ,MAAM;IACN,aACE;IACH;GACD,MAAM;IACJ,MAAM;IACN,aACE;IACH;GACF;EACD,UAAU,CAAC,QAAQ,OAAO;EAC1B,sBAAsB;EACvB;CACD,UAAU;CACV,MAAM;EAAC;EAAS;EAAe;EAAQ;CACvC,kBAAkB;CACnB;AAED,MAAa,wBAA2C,OACtD,OACA,YAC6B;CAC7B,MAAM,EAAE,WAAW;AAEnB,KAAI;EACF,MAAM,OAAO,MAAM;EACnB,MAAM,OAAO,MAAM;AAEnB,MAAI,CAAC,QAAQ,OAAO,SAAS,SAC3B,QAAO;GACL,SAAS;GACT,OAAO;GACR;AAGH,MAAI,CAAC,QAAQ,OAAO,SAAS,SAC3B,QAAO;GACL,SAAS;GACT,OAAO;GACR;AAGH,SAAO,MAAM,6BAA6B;GACxC,MAAM,KAAK,UAAU,KAAK,CAAC,UAAU,GAAG,IAAI;GAC5C,UAAU,OAAO,KAAK,KAAK;GAC5B,CAAC;EAGF,MAAM,SAAS,UAAU,MAAM,MAAM,KAAK;AAE1C,SAAO;GACL,SAAS;GACT,QAAQ,QAAQ,OAAO;GACxB;UACM,OAAO;EACd,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO,MAAM,oCAAoC,EAAE,OAAO,cAAc,CAAC;AACzE,SAAO;GACL,SAAS;GACT,OAAO,iCAAiC;GACzC"}

package/dist/services/agent-tools/builtin/math-tool.cjs

@@ -0,0 +1,117 @@
+//#region src/services/agent-tools/builtin/math-tool.ts
+const mathToolDefinition = {
+	id: "math_eval",
+	name: "Math Evaluate",
+	description: "Evaluate mathematical expressions. Use this for arithmetic calculations, percentages, and basic math operations. Supports: +, -, *, /, %, ^, parentheses, and common functions like sqrt, sin, cos, tan, log, exp, abs, round, floor, ceil.",
+	inputSchema: {
+		type: "object",
+		properties: {
+			expression: {
+				type: "string",
+				description: "The mathematical expression to evaluate. Examples: '2 + 3 * 4', 'sqrt(16)', '(100 - 20) / 5', 'round(3.7)'"
+			},
+			variables: {
+				type: "object",
+				description: "Optional variables to substitute in the expression. Example: { \"x\": 5, \"y\": 10 } for expression 'x + y'",
+				additionalProperties: { type: "number" }
+			}
+		},
+		required: ["expression"],
+		additionalProperties: false
+	},
+	category: "utility",
+	tags: [
+		"math",
+		"calculation",
+		"arithmetic"
+	],
+	enabledByDefault: true
+};
+const mathFunctions = {
+	sqrt: Math.sqrt,
+	sin: Math.sin,
+	cos: Math.cos,
+	tan: Math.tan,
+	asin: Math.asin,
+	acos: Math.acos,
+	atan: Math.atan,
+	log: Math.log,
+	log10: Math.log10,
+	log2: Math.log2,
+	exp: Math.exp,
+	abs: Math.abs,
+	round: Math.round,
+	floor: Math.floor,
+	ceil: Math.ceil,
+	min: Math.min,
+	max: Math.max,
+	pow: Math.pow,
+	random: Math.random
+};
+const mathConstants = {
+	PI: Math.PI,
+	E: Math.E,
+	LN2: Math.LN2,
+	LN10: Math.LN10
+};
+/**
+* Safe math expression evaluator
+* Only allows numbers, basic operators, parentheses, and whitelisted functions
+*/
+function evaluateMathExpression(expression, variables = {}) {
+	if (!/^[\d\s+\-*/().,%^a-zA-Z_]+$/.test(expression)) throw new Error(`Invalid characters in expression: ${expression}`);
+	let processedExpr = expression;
+	for (const [name, value] of Object.entries(mathConstants)) {
+		const regex = new RegExp(`\\b${name}\\b`, "g");
+		processedExpr = processedExpr.replace(regex, String(value));
+	}
+	for (const [name, value] of Object.entries(variables)) {
+		const regex = new RegExp(`\\b${name}\\b`, "g");
+		processedExpr = processedExpr.replace(regex, String(value));
+	}
+	processedExpr = processedExpr.replace(/\^/g, "**");
+	processedExpr = processedExpr.replace(/(\d+(?:\.\d+)?)\s*%/g, "($1 * 0.01)");
+	for (const funcName of Object.keys(mathFunctions)) {
+		const regex = new RegExp(`\\b${funcName}\\s*\\(`, "g");
+		processedExpr = processedExpr.replace(regex, `Math.${funcName}(`);
+	}
+	if (/\b(?!Math\.)[a-zA-Z_][a-zA-Z0-9_]*\s*\(/.test(processedExpr)) throw new Error(`Unsupported function call in expression: ${expression}`);
+	try {
+		const result = new Function("Math", `"use strict"; return (${processedExpr});`)(Math);
+		if (typeof result !== "number" || !isFinite(result)) throw new Error(`Invalid result: ${result}`);
+		return result;
+	} catch (error) {
+		throw new Error(`Failed to evaluate expression: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+const mathToolExecutor = async (input, context) => {
+	const { logger } = context;
+	try {
+		const expression = input.expression;
+		const variables = input.variables || {};
+		if (!expression || typeof expression !== "string") return {
+			success: false,
+			error: "Expression must be a non-empty string"
+		};
+		logger.debug("Executing math tool", {
+			expression,
+			variables
+		});
+		return {
+			success: true,
+			output: evaluateMathExpression(expression.trim(), variables)
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("Math tool execution failed", { error: errorMessage });
+		return {
+			success: false,
+			error: `Math evaluation failed: ${errorMessage}`
+		};
+	}
+};
+//#endregion
+exports.mathToolDefinition = mathToolDefinition;
+exports.mathToolExecutor = mathToolExecutor;
+
+//# sourceMappingURL=math-tool.cjs.map