@agentforge/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3905 @@
+// src/tools/types.ts
+var ToolCategory = /* @__PURE__ */ ((ToolCategory2) => {
+  ToolCategory2["FILE_SYSTEM"] = "file-system";
+  ToolCategory2["WEB"] = "web";
+  ToolCategory2["CODE"] = "code";
+  ToolCategory2["DATABASE"] = "database";
+  ToolCategory2["API"] = "api";
+  ToolCategory2["UTILITY"] = "utility";
+  ToolCategory2["CUSTOM"] = "custom";
+  return ToolCategory2;
+})(ToolCategory || {});
+
+// src/tools/schemas.ts
+import { z } from "zod";
+var ToolCategorySchema = z.nativeEnum(ToolCategory, {
+  errorMap: () => ({
+    message: `Must be a valid ToolCategory: ${Object.values(ToolCategory).join(", ")}`
+  })
+});
+var ToolExampleSchema = z.object({
+  /**
+   * Description must be a non-empty string
+   */
+  description: z.string().min(1, "Example description cannot be empty"),
+  /**
+   * Input must be an object (can have any properties)
+   */
+  input: z.record(z.unknown()),
+  /**
+   * Output is optional and can be anything
+   */
+  output: z.unknown().optional(),
+  /**
+   * Explanation is optional but must be non-empty if provided
+   */
+  explanation: z.string().min(1).optional()
+});
+var ToolNameSchema = z.string().min(2, "Tool name must be at least 2 characters").max(50, "Tool name must be at most 50 characters").regex(
+  /^[a-z][a-z0-9-]*[a-z0-9]$/,
+  "Tool name must be kebab-case (lowercase letters, numbers, hyphens only, must start with a letter)"
+);
+var ToolMetadataSchema = z.object({
+  // ===== REQUIRED FIELDS =====
+  /**
+   * Tool name - must be valid kebab-case
+   */
+  name: ToolNameSchema,
+  /**
+   * Description - must be meaningful (at least 10 characters)
+   */
+  description: z.string().min(10, "Tool description must be at least 10 characters").max(500, "Tool description must be at most 500 characters"),
+  /**
+   * Category - must be a valid ToolCategory
+   */
+  category: ToolCategorySchema,
+  // ===== OPTIONAL FIELDS =====
+  /**
+   * Display name - if provided, must be non-empty
+   */
+  displayName: z.string().min(1).optional(),
+  /**
+   * Tags - array of non-empty strings
+   */
+  tags: z.array(z.string().min(1)).optional(),
+  /**
+   * Examples - array of valid ToolExample objects
+   */
+  examples: z.array(ToolExampleSchema).optional(),
+  /**
+   * Usage notes - if provided, must be meaningful
+   */
+  usageNotes: z.string().min(10).optional(),
+  /**
+   * Limitations - array of non-empty strings
+   */
+  limitations: z.array(z.string().min(1)).optional(),
+  /**
+   * Version - if provided, should follow semver format
+   * Examples: '1.0.0', '2.1.3', '0.1.0-beta', '1.0.0-alpha.1'
+   */
+  version: z.string().regex(
+    /^\d+\.\d+\.\d+(-[a-z0-9.-]+)?$/i,
+    "Version should follow semantic versioning (e.g., 1.0.0)"
+  ).optional(),
+  /**
+   * Author - if provided, must be non-empty
+   */
+  author: z.string().min(1).optional(),
+  /**
+   * Deprecated flag
+   */
+  deprecated: z.boolean().optional(),
+  /**
+   * Replacement tool name - if provided, must be valid tool name
+   */
+  replacedBy: ToolNameSchema.optional()
+});
+function validateToolMetadata(metadata) {
+  return ToolMetadataSchema.safeParse(metadata);
+}
+function validateToolName(name) {
+  return ToolNameSchema.safeParse(name).success;
+}
+
+// src/tools/validation.ts
+import { z as z2 } from "zod";
+var MissingDescriptionError = class extends Error {
+  constructor(fieldPath, fieldType) {
+    super(
+      `Schema field "${fieldPath.join(".")}" (${fieldType}) is missing a description. All fields must have descriptions for LLM understanding. Use .describe("...") on this field.`
+    );
+    this.fieldPath = fieldPath;
+    this.fieldType = fieldType;
+    this.name = "MissingDescriptionError";
+  }
+};
+function validateSchemaDescriptions(schema, fieldPath = []) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  if (schema instanceof z2.ZodObject) {
+    const shape = schema.shape;
+    Object.entries(shape).forEach(([key, fieldSchema]) => {
+      validateSchemaDescriptions(fieldSchema, [...fieldPath, key]);
+    });
+    return;
+  }
+  if (schema instanceof z2.ZodArray) {
+    validateSchemaDescriptions(def.type, [...fieldPath, "[]"]);
+    return;
+  }
+  if (schema instanceof z2.ZodOptional) {
+    const wrapperDescription = def.description;
+    const innerDescription = def.innerType._def.description;
+    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
+      throw new MissingDescriptionError(fieldPath, typeName);
+    }
+    if (!wrapperDescription) {
+      validateSchemaDescriptions(def.innerType, fieldPath);
+    }
+    return;
+  }
+  if (schema instanceof z2.ZodNullable) {
+    const wrapperDescription = def.description;
+    const innerDescription = def.innerType._def.description;
+    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
+      throw new MissingDescriptionError(fieldPath, typeName);
+    }
+    if (!wrapperDescription) {
+      validateSchemaDescriptions(def.innerType, fieldPath);
+    }
+    return;
+  }
+  if (schema instanceof z2.ZodDefault) {
+    const wrapperDescription = def.description;
+    const innerDescription = def.innerType._def.description;
+    if (fieldPath.length > 0 && !wrapperDescription && !innerDescription) {
+      throw new MissingDescriptionError(fieldPath, typeName);
+    }
+    if (!wrapperDescription) {
+      validateSchemaDescriptions(def.innerType, fieldPath);
+    }
+    return;
+  }
+  if (schema instanceof z2.ZodUnion) {
+    def.options.forEach((option, index) => {
+      validateSchemaDescriptions(option, [...fieldPath, `option${index}`]);
+    });
+    return;
+  }
+  if (schema instanceof z2.ZodIntersection) {
+    validateSchemaDescriptions(def.left, fieldPath);
+    validateSchemaDescriptions(def.right, fieldPath);
+    return;
+  }
+  if (schema instanceof z2.ZodRecord) {
+    validateSchemaDescriptions(def.valueType, [...fieldPath, "[key]"]);
+    return;
+  }
+  if (schema instanceof z2.ZodTuple) {
+    def.items.forEach((item, index) => {
+      validateSchemaDescriptions(item, [...fieldPath, `[${index}]`]);
+    });
+    return;
+  }
+  if (fieldPath.length > 0) {
+    const description = def.description;
+    if (!description || description.trim() === "") {
+      throw new MissingDescriptionError(fieldPath, typeName);
+    }
+  }
+}
+function safeValidateSchemaDescriptions(schema) {
+  try {
+    validateSchemaDescriptions(schema);
+    return { success: true };
+  } catch (error) {
+    if (error instanceof MissingDescriptionError) {
+      return { success: false, error };
+    }
+    throw error;
+  }
+}
+function getMissingDescriptions(schema) {
+  const missing = [];
+  function check(s, path = []) {
+    const def = s._def;
+    const typeName = def.typeName;
+    if (s instanceof z2.ZodObject) {
+      const shape = s.shape;
+      Object.entries(shape).forEach(([key, fieldSchema]) => {
+        check(fieldSchema, [...path, key]);
+      });
+      return;
+    }
+    if (s instanceof z2.ZodOptional || s instanceof z2.ZodNullable || s instanceof z2.ZodDefault) {
+      const wrapperDescription = def.description;
+      const innerDescription = def.innerType._def.description;
+      if (path.length > 0 && !wrapperDescription && !innerDescription) {
+        missing.push(path.join("."));
+      }
+      if (!wrapperDescription) {
+        check(def.innerType, path);
+      }
+      return;
+    }
+    if (s instanceof z2.ZodArray) {
+      check(def.type, [...path, "[]"]);
+      return;
+    }
+    if (path.length > 0) {
+      const description = def.description;
+      if (!description || description.trim() === "") {
+        missing.push(path.join("."));
+      }
+    }
+  }
+  check(schema);
+  return missing;
+}
+
+// src/tools/helpers.ts
+function createTool(metadata, schema, execute) {
+  const metadataResult = validateToolMetadata(metadata);
+  if (!metadataResult.success) {
+    const errors = metadataResult.error.errors.map((err) => `  - ${err.path.join(".")}: ${err.message}`).join("\n");
+    throw new Error(`Invalid tool metadata:
+${errors}`);
+  }
+  validateSchemaDescriptions(schema);
+  return {
+    metadata: metadataResult.data,
+    schema,
+    execute
+  };
+}
+function createToolUnsafe(metadata, schema, execute) {
+  const metadataResult = validateToolMetadata(metadata);
+  if (!metadataResult.success) {
+    const errors = metadataResult.error.errors.map((err) => `  - ${err.path.join(".")}: ${err.message}`).join("\n");
+    throw new Error(`Invalid tool metadata:
+${errors}`);
+  }
+  return {
+    metadata: metadataResult.data,
+    schema,
+    execute
+  };
+}
+function validateTool(tool) {
+  const errors = [];
+  const metadataResult = validateToolMetadata(tool.metadata);
+  if (!metadataResult.success) {
+    metadataResult.error.errors.forEach((err) => {
+      errors.push(`Metadata: ${err.path.join(".")}: ${err.message}`);
+    });
+  }
+  try {
+    validateSchemaDescriptions(tool.schema);
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Schema: ${error.message}`);
+    }
+  }
+  return {
+    success: errors.length === 0,
+    errors
+  };
+}
+
+// src/tools/builder.ts
+var ToolBuilder = class {
+  metadata = {};
+  _schema;
+  _execute;
+  /**
+   * Set the tool name (required)
+   * 
+   * @param name - Tool name in kebab-case (e.g., 'read-file')
+   */
+  name(name) {
+    this.metadata.name = name;
+    return this;
+  }
+  /**
+   * Set the tool description (required)
+   * 
+   * @param description - Clear description of what the tool does
+   */
+  description(description) {
+    this.metadata.description = description;
+    return this;
+  }
+  /**
+   * Set the tool category (required)
+   * 
+   * @param category - Tool category for organization
+   */
+  category(category) {
+    this.metadata.category = category;
+    return this;
+  }
+  /**
+   * Set the display name (optional)
+   * 
+   * @param displayName - Human-friendly name for UI display
+   */
+  displayName(displayName) {
+    this.metadata.displayName = displayName;
+    return this;
+  }
+  /**
+   * Set tags for searchability (optional)
+   * 
+   * @param tags - Array of tags for categorization and search
+   */
+  tags(tags) {
+    this.metadata.tags = tags;
+    return this;
+  }
+  /**
+   * Add a single tag (optional)
+   * 
+   * @param tag - Tag to add
+   */
+  tag(tag) {
+    if (!this.metadata.tags) {
+      this.metadata.tags = [];
+    }
+    this.metadata.tags.push(tag);
+    return this;
+  }
+  /**
+   * Add an example (optional)
+   * 
+   * @param example - Usage example for the tool
+   */
+  example(example) {
+    if (!this.metadata.examples) {
+      this.metadata.examples = [];
+    }
+    this.metadata.examples.push(example);
+    return this;
+  }
+  /**
+   * Set usage notes (optional)
+   * 
+   * @param notes - Important usage information
+   */
+  usageNotes(notes) {
+    this.metadata.usageNotes = notes;
+    return this;
+  }
+  /**
+   * Set limitations (optional)
+   * 
+   * @param limitations - Array of known limitations
+   */
+  limitations(limitations) {
+    this.metadata.limitations = limitations;
+    return this;
+  }
+  /**
+   * Add a single limitation (optional)
+   * 
+   * @param limitation - Limitation to add
+   */
+  limitation(limitation) {
+    if (!this.metadata.limitations) {
+      this.metadata.limitations = [];
+    }
+    this.metadata.limitations.push(limitation);
+    return this;
+  }
+  /**
+   * Set version (optional)
+   * 
+   * @param version - Semantic version string
+   */
+  version(version) {
+    this.metadata.version = version;
+    return this;
+  }
+  /**
+   * Set author (optional)
+   * 
+   * @param author - Tool author name
+   */
+  author(author) {
+    this.metadata.author = author;
+    return this;
+  }
+  /**
+   * Set the input schema (required)
+   * 
+   * All fields MUST have .describe() for LLM understanding!
+   * 
+   * @param schema - Zod schema for input validation
+   */
+  schema(schema) {
+    this._schema = schema;
+    return this;
+  }
+  /**
+   * Set the implementation function (required)
+   * 
+   * @param execute - Async function that implements the tool
+   */
+  implement(execute) {
+    this._execute = execute;
+    return this;
+  }
+  /**
+   * Build the tool with validation
+   * 
+   * Validates:
+   * - All required fields are present
+   * - Metadata is valid
+   * - Schema has descriptions on all fields
+   * 
+   * @returns The validated tool
+   * @throws {Error} If validation fails
+   */
+  build() {
+    if (!this.metadata.name) {
+      throw new Error("Tool name is required. Use .name() to set it.");
+    }
+    if (!this.metadata.description) {
+      throw new Error("Tool description is required. Use .description() to set it.");
+    }
+    if (!this.metadata.category) {
+      throw new Error("Tool category is required. Use .category() to set it.");
+    }
+    if (!this._schema) {
+      throw new Error("Tool schema is required. Use .schema() to set it.");
+    }
+    if (!this._execute) {
+      throw new Error("Tool implementation is required. Use .implement() to set it.");
+    }
+    return createTool(
+      this.metadata,
+      this._schema,
+      this._execute
+    );
+  }
+};
+function toolBuilder() {
+  return new ToolBuilder();
+}
+
+// src/langchain/converter.ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { zodToJsonSchema } from "zod-to-json-schema";
+function toLangChainTool(tool) {
+  return new DynamicStructuredTool({
+    name: tool.metadata.name,
+    description: tool.metadata.description,
+    schema: tool.schema,
+    func: async (input) => {
+      const result = await tool.execute(input);
+      if (typeof result === "string") {
+        return result;
+      }
+      if (typeof result === "object" && result !== null) {
+        return JSON.stringify(result, null, 2);
+      }
+      return String(result);
+    }
+  });
+}
+function toLangChainTools(tools) {
+  return tools.map(toLangChainTool);
+}
+function getToolJsonSchema(tool) {
+  const jsonSchema = zodToJsonSchema(tool.schema, {
+    name: tool.metadata.name,
+    $refStrategy: "none"
+    // Don't use $ref for nested schemas
+  });
+  if (jsonSchema.$ref && jsonSchema.definitions) {
+    const refName = jsonSchema.$ref.replace("#/definitions/", "");
+    return jsonSchema.definitions[refName] || jsonSchema;
+  }
+  return jsonSchema;
+}
+function getToolDescription(tool) {
+  const { metadata } = tool;
+  const parts = [];
+  parts.push(`${metadata.name}: ${metadata.description}`);
+  if (metadata.displayName) {
+    parts.push(`Display Name: ${metadata.displayName}`);
+  }
+  parts.push(`Category: ${metadata.category}`);
+  if (metadata.tags && metadata.tags.length > 0) {
+    parts.push(`Tags: ${metadata.tags.join(", ")}`);
+  }
+  if (metadata.usageNotes) {
+    parts.push(`
+Usage Notes: ${metadata.usageNotes}`);
+  }
+  if (metadata.limitations && metadata.limitations.length > 0) {
+    parts.push(`
+Limitations:`);
+    metadata.limitations.forEach((limit) => {
+      parts.push(`  - ${limit}`);
+    });
+  }
+  if (metadata.examples && metadata.examples.length > 0) {
+    parts.push(`
+Examples:`);
+    metadata.examples.forEach((example, i) => {
+      parts.push(`  ${i + 1}. ${example.description}`);
+      if (example.explanation) {
+        parts.push(`     ${example.explanation}`);
+      }
+    });
+  }
+  return parts.join("\n");
+}
+
+// src/tools/registry.ts
+var RegistryEvent = /* @__PURE__ */ ((RegistryEvent2) => {
+  RegistryEvent2["TOOL_REGISTERED"] = "tool:registered";
+  RegistryEvent2["TOOL_REMOVED"] = "tool:removed";
+  RegistryEvent2["TOOL_UPDATED"] = "tool:updated";
+  RegistryEvent2["REGISTRY_CLEARED"] = "registry:cleared";
+  return RegistryEvent2;
+})(RegistryEvent || {});
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool in the registry
+   * 
+   * @param tool - The tool to register
+   * @throws Error if a tool with the same name already exists
+   * 
+   * @example
+   * ```ts
+   * registry.register(readFileTool);
+   * ```
+   */
+  register(tool) {
+    const name = tool.metadata.name;
+    if (this.tools.has(name)) {
+      throw new Error(
+        `Tool with name "${name}" is already registered. Use update() to modify it.`
+      );
+    }
+    this.tools.set(name, tool);
+    this.emit("tool:registered" /* TOOL_REGISTERED */, tool);
+  }
+  /**
+   * Get a tool by name
+   * 
+   * @param name - The tool name
+   * @returns The tool, or undefined if not found
+   * 
+   * @example
+   * ```ts
+   * const tool = registry.get('read-file');
+   * if (tool) {
+   *   const result = await tool.execute({ path: './file.txt' });
+   * }
+   * ```
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Check if a tool exists in the registry
+   * 
+   * @param name - The tool name
+   * @returns True if the tool exists
+   * 
+   * @example
+   * ```ts
+   * if (registry.has('read-file')) {
+   *   console.log('Tool exists!');
+   * }
+   * ```
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Remove a tool from the registry
+   * 
+   * @param name - The tool name
+   * @returns True if the tool was removed, false if it didn't exist
+   * 
+   * @example
+   * ```ts
+   * const removed = registry.remove('read-file');
+   * console.log(removed ? 'Removed' : 'Not found');
+   * ```
+   */
+  remove(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return false;
+    }
+    this.tools.delete(name);
+    this.emit("tool:removed" /* TOOL_REMOVED */, tool);
+    return true;
+  }
+  /**
+   * Update an existing tool
+   *
+   * @param name - The tool name
+   * @param tool - The new tool definition
+   * @returns True if updated, false if the tool didn't exist
+   *
+   * @example
+   * ```ts
+   * const updated = registry.update('read-file', newReadFileTool);
+   * ```
+   */
+  update(name, tool) {
+    if (!this.tools.has(name)) {
+      return false;
+    }
+    this.tools.set(name, tool);
+    this.emit("tool:updated" /* TOOL_UPDATED */, { name, tool });
+    return true;
+  }
+  /**
+   * Get all registered tools
+   *
+   * @returns Array of all tools
+   *
+   * @example
+   * ```ts
+   * const allTools = registry.getAll();
+   * console.log(`Total tools: ${allTools.length}`);
+   * ```
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get tools by category
+   *
+   * @param category - The tool category
+   * @returns Array of tools in the category
+   *
+   * @example
+   * ```ts
+   * const fileTools = registry.getByCategory(ToolCategory.FILE_SYSTEM);
+   * ```
+   */
+  getByCategory(category) {
+    return this.getAll().filter((tool) => tool.metadata.category === category);
+  }
+  /**
+   * Get tools by tag
+   *
+   * @param tag - The tag to search for
+   * @returns Array of tools with the tag
+   *
+   * @example
+   * ```ts
+   * const fileTools = registry.getByTag('file');
+   * ```
+   */
+  getByTag(tag) {
+    return this.getAll().filter(
+      (tool) => tool.metadata.tags?.includes(tag)
+    );
+  }
+  /**
+   * Search tools by name or description
+   *
+   * Case-insensitive search across tool names, display names, and descriptions.
+   *
+   * @param query - The search query
+   * @returns Array of matching tools
+   *
+   * @example
+   * ```ts
+   * const results = registry.search('file');
+   * // Returns tools with 'file' in name or description
+   * ```
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter((tool) => {
+      const name = tool.metadata.name.toLowerCase();
+      const displayName = tool.metadata.displayName?.toLowerCase() || "";
+      const description = tool.metadata.description.toLowerCase();
+      return name.includes(lowerQuery) || displayName.includes(lowerQuery) || description.includes(lowerQuery);
+    });
+  }
+  /**
+   * Register multiple tools at once
+   *
+   * @param tools - Array of tools to register
+   * @throws Error if any tool name conflicts with existing tools
+   *
+   * @example
+   * ```ts
+   * registry.registerMany([tool1, tool2, tool3]);
+   * ```
+   */
+  registerMany(tools) {
+    const conflicts = [];
+    for (const tool of tools) {
+      if (this.tools.has(tool.metadata.name)) {
+        conflicts.push(tool.metadata.name);
+      }
+    }
+    if (conflicts.length > 0) {
+      throw new Error(
+        `Cannot register tools: the following names already exist: ${conflicts.join(", ")}`
+      );
+    }
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+  /**
+   * Clear all tools from the registry
+   *
+   * @example
+   * ```ts
+   * registry.clear();
+   * console.log(registry.size()); // 0
+   * ```
+   */
+  clear() {
+    this.tools.clear();
+    this.emit("registry:cleared" /* REGISTRY_CLEARED */, null);
+  }
+  /**
+   * Get the number of registered tools
+   *
+   * @returns Number of tools in the registry
+   *
+   * @example
+   * ```ts
+   * console.log(`Registry has ${registry.size()} tools`);
+   * ```
+   */
+  size() {
+    return this.tools.size;
+  }
+  /**
+   * Get all tool names
+   *
+   * @returns Array of tool names
+   *
+   * @example
+   * ```ts
+   * const names = registry.getNames();
+   * console.log('Available tools:', names.join(', '));
+   * ```
+   */
+  getNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Register an event handler
+   *
+   * @param event - The event to listen for
+   * @param handler - The handler function
+   *
+   * @example
+   * ```ts
+   * registry.on(RegistryEvent.TOOL_REGISTERED, (tool) => {
+   *   console.log('New tool:', tool.metadata.name);
+   * });
+   * ```
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unregister an event handler
+   *
+   * @param event - The event to stop listening for
+   * @param handler - The handler function to remove
+   *
+   * @example
+   * ```ts
+   * const handler = (tool) => console.log(tool);
+   * registry.on(RegistryEvent.TOOL_REGISTERED, handler);
+   * registry.off(RegistryEvent.TOOL_REGISTERED, handler);
+   * ```
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event to all registered handlers
+   *
+   * @param event - The event to emit
+   * @param data - The event data
+   * @private
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Convert all registered tools to LangChain format
+   *
+   * This allows the entire registry to be used with LangChain agents.
+   *
+   * @returns Array of LangChain DynamicStructuredTools
+   *
+   * @example
+   * ```ts
+   * const registry = new ToolRegistry();
+   * registry.registerMany([tool1, tool2, tool3]);
+   *
+   * const langchainTools = registry.toLangChainTools();
+   *
+   * const agent = createAgent({
+   *   model: new ChatOpenAI(),
+   *   tools: langchainTools,
+   * });
+   * ```
+   */
+  toLangChainTools() {
+    return toLangChainTools(this.getAll());
+  }
+  /**
+   * Generate a formatted prompt describing all tools
+   *
+   * Creates a human-readable description of all tools in the registry,
+   * suitable for inclusion in LLM prompts.
+   *
+   * @param options - Options for customizing the prompt
+   * @returns Formatted prompt string
+   *
+   * @example
+   * ```ts
+   * const prompt = registry.generatePrompt({
+   *   includeExamples: true,
+   *   groupByCategory: true,
+   *   maxExamplesPerTool: 2,
+   * });
+   *
+   * console.log(prompt);
+   * // Available Tools:
+   * //
+   * // FILE SYSTEM TOOLS:
+   * // - read-file: Read a file from the file system
+   * //   Parameters: path (string)
+   * //   Example: Read a text file
+   * //     Input: { "path": "./README.md" }
+   * // ...
+   * ```
+   */
+  generatePrompt(options = {}) {
+    const {
+      includeExamples = false,
+      includeNotes = false,
+      includeLimitations = false,
+      groupByCategory = false,
+      categories,
+      maxExamplesPerTool
+    } = options;
+    let tools = this.getAll();
+    if (categories && categories.length > 0) {
+      tools = tools.filter((tool) => categories.includes(tool.metadata.category));
+    }
+    if (tools.length === 0) {
+      return "No tools available.";
+    }
+    const lines = ["Available Tools:", ""];
+    if (groupByCategory) {
+      const toolsByCategory = /* @__PURE__ */ new Map();
+      for (const tool of tools) {
+        const category = tool.metadata.category;
+        if (!toolsByCategory.has(category)) {
+          toolsByCategory.set(category, []);
+        }
+        toolsByCategory.get(category).push(tool);
+      }
+      for (const [category, categoryTools] of toolsByCategory) {
+        lines.push(`${category.toUpperCase().replace(/-/g, " ")} TOOLS:`);
+        for (const tool of categoryTools) {
+          lines.push(...this.formatToolForPrompt(tool, {
+            includeExamples,
+            includeNotes,
+            includeLimitations,
+            maxExamplesPerTool
+          }));
+        }
+        lines.push("");
+      }
+    } else {
+      for (const tool of tools) {
+        lines.push(...this.formatToolForPrompt(tool, {
+          includeExamples,
+          includeNotes,
+          includeLimitations,
+          maxExamplesPerTool
+        }));
+        lines.push("");
+      }
+    }
+    return lines.join("\n").trim();
+  }
+  /**
+   * Format a single tool for inclusion in a prompt
+   *
+   * @param tool - The tool to format
+   * @param options - Formatting options
+   * @returns Array of formatted lines
+   * @private
+   */
+  formatToolForPrompt(tool, options) {
+    const { metadata } = tool;
+    const lines = [];
+    lines.push(`- ${metadata.name}: ${metadata.description}`);
+    const schemaShape = tool.schema._def?.shape?.();
+    if (schemaShape) {
+      const params = Object.keys(schemaShape);
+      if (params.length > 0) {
+        const paramDescriptions = params.map((param) => {
+          const field = schemaShape[param];
+          const type = field._def?.typeName?.replace("Zod", "").toLowerCase() || "any";
+          return `${param} (${type})`;
+        });
+        lines.push(`  Parameters: ${paramDescriptions.join(", ")}`);
+      }
+    }
+    if (options.includeNotes && metadata.usageNotes) {
+      lines.push(`  Notes: ${metadata.usageNotes}`);
+    }
+    if (options.includeExamples && metadata.examples && metadata.examples.length > 0) {
+      const maxExamples = options.maxExamplesPerTool || metadata.examples.length;
+      const examples = metadata.examples.slice(0, maxExamples);
+      for (const example of examples) {
+        lines.push(`  Example: ${example.description}`);
+        lines.push(`    Input: ${JSON.stringify(example.input)}`);
+        if (example.explanation) {
+          lines.push(`    ${example.explanation}`);
+        }
+      }
+    }
+    if (options.includeLimitations && metadata.limitations && metadata.limitations.length > 0) {
+      lines.push(`  Limitations:`);
+      for (const limitation of metadata.limitations) {
+        lines.push(`    - ${limitation}`);
+      }
+    }
+    return lines;
+  }
+};
+
+// src/tools/executor.ts
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  normal: 2,
+  low: 3
+};
+function createToolExecutor(config = {}) {
+  const {
+    maxConcurrent = 5,
+    timeout: timeout2 = 3e4,
+    retryPolicy,
+    priorityFn = () => "normal",
+    onExecutionStart,
+    onExecutionComplete,
+    onExecutionError
+  } = config;
+  let activeExecutions = 0;
+  const queue = [];
+  const metrics = {
+    totalExecutions: 0,
+    successfulExecutions: 0,
+    failedExecutions: 0,
+    totalDuration: 0,
+    averageDuration: 0,
+    byPriority: { low: 0, normal: 0, high: 0, critical: 0 }
+  };
+  function calculateBackoff(attempt, policy) {
+    const initialDelay = policy.initialDelay || 1e3;
+    const maxDelay = policy.maxDelay || 3e4;
+    let delay;
+    switch (policy.backoff) {
+      case "linear":
+        delay = initialDelay * attempt;
+        break;
+      case "exponential":
+        delay = initialDelay * Math.pow(2, attempt - 1);
+        break;
+      case "fixed":
+      default:
+        delay = initialDelay;
+    }
+    return Math.min(delay, maxDelay);
+  }
+  async function executeWithRetry(tool, input, policy) {
+    if (!policy) {
+      return await tool.invoke(input);
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+      try {
+        return await tool.invoke(input);
+      } catch (error) {
+        lastError = error;
+        if (policy.retryableErrors && policy.retryableErrors.length > 0) {
+          const isRetryable = policy.retryableErrors.some(
+            (msg) => lastError.message.includes(msg)
+          );
+          if (!isRetryable) {
+            throw lastError;
+          }
+        }
+        if (attempt < policy.maxAttempts) {
+          const delay = calculateBackoff(attempt, policy);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async function executeSingle(tool, input, priority) {
+    const startTime = Date.now();
+    try {
+      onExecutionStart?.(tool, input);
+      const result = await Promise.race([
+        executeWithRetry(tool, input, retryPolicy),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Tool execution timeout")), timeout2)
+        )
+      ]);
+      const duration = Date.now() - startTime;
+      metrics.totalExecutions++;
+      metrics.successfulExecutions++;
+      metrics.totalDuration += duration;
+      metrics.averageDuration = metrics.totalDuration / metrics.totalExecutions;
+      metrics.byPriority[priority]++;
+      onExecutionComplete?.(tool, input, result, duration);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      metrics.totalExecutions++;
+      metrics.failedExecutions++;
+      metrics.totalDuration += duration;
+      metrics.averageDuration = metrics.totalDuration / metrics.totalExecutions;
+      onExecutionError?.(tool, input, error, duration);
+      throw error;
+    }
+  }
+  async function processQueue() {
+    while (queue.length > 0 && activeExecutions < maxConcurrent) {
+      queue.sort((a, b) => {
+        const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+        if (priorityDiff !== 0) return priorityDiff;
+        return a.timestamp - b.timestamp;
+      });
+      const execution = queue.shift();
+      if (!execution) break;
+      activeExecutions++;
+      executeSingle(execution.tool, execution.input, execution.priority).then((result) => {
+        execution.resolve(result);
+      }).catch((error) => {
+        execution.reject(error);
+      }).finally(() => {
+        activeExecutions--;
+        processQueue();
+      });
+    }
+  }
+  async function execute(tool, input, options = {}) {
+    const priority = options.priority || priorityFn(tool);
+    return new Promise((resolve, reject) => {
+      queue.push({
+        tool,
+        input,
+        priority,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      });
+      processQueue();
+    });
+  }
+  async function executeParallel(executions) {
+    return Promise.all(
+      executions.map(
+        (exec) => execute(exec.tool, exec.input, { priority: exec.priority })
+      )
+    );
+  }
+  function getMetrics() {
+    return { ...metrics };
+  }
+  function resetMetrics() {
+    metrics.totalExecutions = 0;
+    metrics.successfulExecutions = 0;
+    metrics.failedExecutions = 0;
+    metrics.totalDuration = 0;
+    metrics.averageDuration = 0;
+    metrics.byPriority = { low: 0, normal: 0, high: 0, critical: 0 };
+  }
+  function getQueueStatus() {
+    return {
+      queueLength: queue.length,
+      activeExecutions,
+      maxConcurrent
+    };
+  }
+  return {
+    execute,
+    executeParallel,
+    getMetrics,
+    resetMetrics,
+    getQueueStatus
+  };
+}
+
+// src/tools/lifecycle.ts
+var ManagedTool = class {
+  name;
+  description;
+  initializeFn;
+  executeFn;
+  cleanupFn;
+  healthCheckFn;
+  autoCleanup;
+  healthCheckInterval;
+  _initialized = false;
+  _context;
+  _stats = {
+    initialized: false,
+    totalExecutions: 0,
+    successfulExecutions: 0,
+    failedExecutions: 0
+  };
+  _healthCheckTimer;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.initializeFn = config.initialize?.bind(this);
+    this.executeFn = config.execute.bind(this);
+    this.cleanupFn = config.cleanup?.bind(this);
+    this.healthCheckFn = config.healthCheck?.bind(this);
+    this.autoCleanup = config.autoCleanup ?? true;
+    this.healthCheckInterval = config.healthCheckInterval;
+    this._context = config.context;
+    if (this.autoCleanup) {
+      process.on("beforeExit", () => {
+        this.cleanup().catch(console.error);
+      });
+    }
+  }
+  /**
+   * Get the tool context (e.g., connection pool, API client)
+   */
+  get context() {
+    return this._context;
+  }
+  /**
+   * Set the tool context
+   */
+  set context(value) {
+    this._context = value;
+  }
+  /**
+   * Check if tool is initialized
+   */
+  get initialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the tool
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    if (this.initializeFn) {
+      await this.initializeFn();
+    }
+    this._initialized = true;
+    this._stats.initialized = true;
+    if (this.healthCheckInterval && this.healthCheckFn) {
+      this._healthCheckTimer = setInterval(async () => {
+        try {
+          const result = await this.healthCheckFn();
+          this._stats.lastHealthCheck = result;
+          this._stats.lastHealthCheckTime = Date.now();
+        } catch (error) {
+          this._stats.lastHealthCheck = {
+            healthy: false,
+            error: error.message
+          };
+          this._stats.lastHealthCheckTime = Date.now();
+        }
+      }, this.healthCheckInterval);
+    }
+  }
+  /**
+   * Execute the tool
+   */
+  async execute(input) {
+    if (!this._initialized) {
+      throw new Error(`Tool ${this.name} is not initialized. Call initialize() first.`);
+    }
+    const startTime = Date.now();
+    this._stats.totalExecutions++;
+    try {
+      const result = await this.executeFn(input);
+      this._stats.successfulExecutions++;
+      this._stats.lastExecutionTime = Date.now() - startTime;
+      return result;
+    } catch (error) {
+      this._stats.failedExecutions++;
+      this._stats.lastExecutionTime = Date.now() - startTime;
+      throw error;
+    }
+  }
+  /**
+   * Cleanup the tool
+   */
+  async cleanup() {
+    if (!this._initialized) {
+      return;
+    }
+    if (this._healthCheckTimer) {
+      clearInterval(this._healthCheckTimer);
+      this._healthCheckTimer = void 0;
+    }
+    if (this.cleanupFn) {
+      await this.cleanupFn();
+    }
+    this._initialized = false;
+    this._stats.initialized = false;
+  }
+  /**
+   * Run health check
+   */
+  async healthCheck() {
+    if (!this._initialized) {
+      return {
+        healthy: false,
+        error: "Tool is not initialized"
+      };
+    }
+    if (!this.healthCheckFn) {
+      return {
+        healthy: true,
+        metadata: { message: "No health check configured" }
+      };
+    }
+    try {
+      const result = await this.healthCheckFn();
+      this._stats.lastHealthCheck = result;
+      this._stats.lastHealthCheckTime = Date.now();
+      return result;
+    } catch (error) {
+      const result = {
+        healthy: false,
+        error: error.message
+      };
+      this._stats.lastHealthCheck = result;
+      this._stats.lastHealthCheckTime = Date.now();
+      return result;
+    }
+  }
+  /**
+   * Get tool statistics
+   */
+  getStats() {
+    return { ...this._stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this._stats.totalExecutions = 0;
+    this._stats.successfulExecutions = 0;
+    this._stats.failedExecutions = 0;
+    this._stats.lastExecutionTime = void 0;
+  }
+  /**
+   * Convert to LangChain tool format
+   */
+  toLangChainTool() {
+    return {
+      name: this.name,
+      description: this.description,
+      invoke: async (input) => {
+        return await this.execute(input);
+      }
+    };
+  }
+};
+function createManagedTool(config) {
+  return new ManagedTool(config);
+}
+
+// src/tools/composition.ts
+function sequential(tools) {
+  return {
+    name: `sequential(${tools.map((t) => t.name).join(" -> ")})`,
+    description: `Execute tools sequentially: ${tools.map((t) => t.name).join(" -> ")}`,
+    invoke: async (input) => {
+      let result = input;
+      for (const tool of tools) {
+        result = await tool.invoke(result);
+      }
+      return result;
+    }
+  };
+}
+function parallel(tools) {
+  return {
+    name: `parallel(${tools.map((t) => t.name).join(", ")})`,
+    description: `Execute tools in parallel: ${tools.map((t) => t.name).join(", ")}`,
+    invoke: async (input) => {
+      const results = await Promise.all(tools.map((tool) => tool.invoke(input)));
+      return results;
+    }
+  };
+}
+function conditional(config) {
+  return {
+    name: `conditional(${config.onTrue.name} | ${config.onFalse.name})`,
+    description: `Conditionally execute ${config.onTrue.name} or ${config.onFalse.name}`,
+    invoke: async (input) => {
+      const shouldExecuteTrue = await config.condition(input);
+      const tool = shouldExecuteTrue ? config.onTrue : config.onFalse;
+      return await tool.invoke(input);
+    }
+  };
+}
+function composeTool(config) {
+  return {
+    name: config.name,
+    description: config.description || `Composed tool: ${config.name}`,
+    invoke: async (input) => {
+      let result = input;
+      for (const step of config.steps) {
+        if (Array.isArray(step)) {
+          result = await parallel(step).invoke(result);
+        } else if ("condition" in step) {
+          result = await conditional(step).invoke(result);
+        } else {
+          result = await step.invoke(result);
+        }
+      }
+      if (config.transformResult) {
+        result = config.transformResult(result);
+      }
+      return result;
+    }
+  };
+}
+function retry(tool, options = {}) {
+  const { maxAttempts = 3, delay = 1e3, backoff = "exponential" } = options;
+  return {
+    name: `retry(${tool.name})`,
+    description: `${tool.description} (with retry)`,
+    invoke: async (input) => {
+      let lastError;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          return await tool.invoke(input);
+        } catch (error) {
+          lastError = error;
+          if (attempt < maxAttempts) {
+            const waitTime = backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+      throw lastError;
+    }
+  };
+}
+function timeout(tool, ms) {
+  return {
+    name: `timeout(${tool.name})`,
+    description: `${tool.description} (with ${ms}ms timeout)`,
+    invoke: async (input) => {
+      return Promise.race([
+        tool.invoke(input),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Tool ${tool.name} timed out after ${ms}ms`)), ms)
+        )
+      ]);
+    }
+  };
+}
+function cache(tool, ttl) {
+  const cacheMap = /* @__PURE__ */ new Map();
+  return {
+    name: `cache(${tool.name})`,
+    description: `${tool.description} (with caching)`,
+    invoke: async (input) => {
+      const key = JSON.stringify(input);
+      const cached = cacheMap.get(key);
+      if (cached) {
+        if (!ttl || Date.now() - cached.timestamp < ttl) {
+          return cached.result;
+        }
+        cacheMap.delete(key);
+      }
+      const result = await tool.invoke(input);
+      cacheMap.set(key, { result, timestamp: Date.now() });
+      return result;
+    }
+  };
+}
+
+// src/tools/testing.ts
+function createMockTool(config) {
+  const {
+    name,
+    description = `Mock tool: ${name}`,
+    responses = [],
+    defaultResponse,
+    latency,
+    errorRate = 0
+  } = config;
+  const invocations = [];
+  return {
+    name,
+    description,
+    invoke: async (input) => {
+      const startTime = Date.now();
+      if (latency) {
+        const delay = typeof latency === "number" ? latency : Math.random() * (latency.max - latency.min) + latency.min;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      if (errorRate > 0 && Math.random() < errorRate) {
+        const error2 = new Error(`Random error from ${name}`);
+        invocations.push({
+          input,
+          error: error2,
+          timestamp: startTime,
+          duration: Date.now() - startTime
+        });
+        throw error2;
+      }
+      const matchingResponse = responses.find((r) => {
+        if (typeof r.input === "function") {
+          return r.input(input);
+        }
+        return JSON.stringify(r.input) === JSON.stringify(input);
+      });
+      if (matchingResponse) {
+        if (matchingResponse.error) {
+          invocations.push({
+            input,
+            error: matchingResponse.error,
+            timestamp: startTime,
+            duration: Date.now() - startTime
+          });
+          throw matchingResponse.error;
+        }
+        invocations.push({
+          input,
+          output: matchingResponse.output,
+          timestamp: startTime,
+          duration: Date.now() - startTime
+        });
+        return matchingResponse.output;
+      }
+      if (defaultResponse !== void 0) {
+        invocations.push({
+          input,
+          output: defaultResponse,
+          timestamp: startTime,
+          duration: Date.now() - startTime
+        });
+        return defaultResponse;
+      }
+      const error = new Error(`No mock response configured for input: ${JSON.stringify(input)}`);
+      invocations.push({
+        input,
+        error,
+        timestamp: startTime,
+        duration: Date.now() - startTime
+      });
+      throw error;
+    },
+    getInvocations: () => [...invocations],
+    clearInvocations: () => {
+      invocations.length = 0;
+    }
+  };
+}
+function createToolSimulator(config) {
+  const { tools, errorRate = 0, latency, recordInvocations = true } = config;
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const invocations = /* @__PURE__ */ new Map();
+  if (recordInvocations) {
+    tools.forEach((t) => invocations.set(t.name, []));
+  }
+  function generateLatency() {
+    if (!latency) return 0;
+    const u1 = Math.random();
+    const u2 = Math.random();
+    const z3 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    return Math.max(0, latency.mean + z3 * latency.stddev);
+  }
+  return {
+    execute: async (toolName, input) => {
+      const tool = toolMap.get(toolName);
+      if (!tool) {
+        throw new Error(`Tool ${toolName} not found in simulator`);
+      }
+      const startTime = Date.now();
+      if (latency) {
+        const delay = generateLatency();
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      if (errorRate > 0 && Math.random() < errorRate) {
+        const error = new Error(`Simulated error from ${toolName}`);
+        if (recordInvocations) {
+          invocations.get(toolName).push({
+            input,
+            error,
+            timestamp: startTime,
+            duration: Date.now() - startTime
+          });
+        }
+        throw error;
+      }
+      try {
+        const result = await tool.invoke(input);
+        if (recordInvocations) {
+          invocations.get(toolName).push({
+            input,
+            output: result,
+            timestamp: startTime,
+            duration: Date.now() - startTime
+          });
+        }
+        return result;
+      } catch (error) {
+        if (recordInvocations) {
+          invocations.get(toolName).push({
+            input,
+            error,
+            timestamp: startTime,
+            duration: Date.now() - startTime
+          });
+        }
+        throw error;
+      }
+    },
+    getInvocations: (toolName) => {
+      return invocations.get(toolName) ? [...invocations.get(toolName)] : [];
+    },
+    getAllInvocations: () => {
+      const all = {};
+      invocations.forEach((invs, name) => {
+        all[name] = [...invs];
+      });
+      return all;
+    },
+    clearInvocations: (toolName) => {
+      if (toolName) {
+        invocations.get(toolName)?.splice(0);
+      } else {
+        invocations.forEach((invs) => invs.splice(0));
+      }
+    }
+  };
+}
+
+// src/langgraph/state.ts
+import { Annotation } from "@langchain/langgraph";
+function createStateAnnotation(config) {
+  const stateDefinition = {};
+  for (const [key, channelConfig] of Object.entries(config)) {
+    if (channelConfig.reducer) {
+      stateDefinition[key] = Annotation({
+        reducer: channelConfig.reducer,
+        default: channelConfig.default
+      });
+    } else {
+      stateDefinition[key] = Annotation();
+    }
+  }
+  return Annotation.Root(stateDefinition);
+}
+function validateState(state, config) {
+  const validated = {};
+  for (const [key, channelConfig] of Object.entries(config)) {
+    if (channelConfig.schema && key in state) {
+      validated[key] = channelConfig.schema.parse(state[key]);
+    } else if (key in state) {
+      validated[key] = state[key];
+    } else if (channelConfig.default) {
+      validated[key] = channelConfig.default();
+    }
+  }
+  return validated;
+}
+function mergeState(currentState, update, config) {
+  const merged = { ...currentState };
+  for (const [key, value] of Object.entries(update)) {
+    const channelConfig = config[key];
+    if (channelConfig?.reducer && key in merged) {
+      merged[key] = channelConfig.reducer(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+
+// src/langgraph/builders/sequential.ts
+import { StateGraph, END, START } from "@langchain/langgraph";
+function createSequentialWorkflow(stateSchema, nodes, options = {}) {
+  const { autoStartEnd = true, name } = options;
+  if (nodes.length === 0) {
+    throw new Error("Sequential workflow must have at least one node");
+  }
+  const nodeNames = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (nodeNames.has(node.name)) {
+      throw new Error(`Duplicate node name: ${node.name}`);
+    }
+    nodeNames.add(node.name);
+  }
+  const graph = new StateGraph(stateSchema);
+  for (const { name: nodeName, node } of nodes) {
+    graph.addNode(nodeName, node);
+  }
+  if (autoStartEnd) {
+    graph.addEdge(START, nodes[0].name);
+  }
+  for (let i = 0; i < nodes.length - 1; i++) {
+    graph.addEdge(nodes[i].name, nodes[i + 1].name);
+  }
+  if (autoStartEnd) {
+    graph.addEdge(nodes[nodes.length - 1].name, END);
+  }
+  return graph;
+}
+function sequentialBuilder(stateSchema) {
+  const nodes = [];
+  let options = {};
+  return {
+    /**
+     * Add a node to the sequential workflow
+     */
+    addNode(name, node, description) {
+      nodes.push({ name, node, description });
+      return this;
+    },
+    /**
+     * Set options for the workflow
+     */
+    options(opts) {
+      options = { ...options, ...opts };
+      return this;
+    },
+    /**
+     * Build the StateGraph
+     */
+    build() {
+      return createSequentialWorkflow(stateSchema, nodes, options);
+    }
+  };
+}
+
+// src/langgraph/builders/parallel.ts
+import { StateGraph as StateGraph2, END as END2, START as START2 } from "@langchain/langgraph";
+function createParallelWorkflow(stateSchema, config, options = {}) {
+  const { parallel: parallel2, aggregate } = config;
+  const { autoStartEnd = true, name } = options;
+  if (parallel2.length === 0) {
+    throw new Error("Parallel workflow must have at least one parallel node");
+  }
+  const nodeNames = /* @__PURE__ */ new Set();
+  for (const node of parallel2) {
+    if (nodeNames.has(node.name)) {
+      throw new Error(`Duplicate node name: ${node.name}`);
+    }
+    nodeNames.add(node.name);
+  }
+  if (aggregate && nodeNames.has(aggregate.name)) {
+    throw new Error(`Duplicate node name: ${aggregate.name}`);
+  }
+  const graph = new StateGraph2(stateSchema);
+  for (const { name: nodeName, node } of parallel2) {
+    graph.addNode(nodeName, node);
+  }
+  if (aggregate) {
+    graph.addNode(aggregate.name, aggregate.node);
+  }
+  if (autoStartEnd) {
+    for (const { name: nodeName } of parallel2) {
+      graph.addEdge(START2, nodeName);
+    }
+  }
+  if (aggregate) {
+    for (const { name: nodeName } of parallel2) {
+      graph.addEdge(nodeName, aggregate.name);
+    }
+    if (autoStartEnd) {
+      graph.addEdge(aggregate.name, END2);
+    }
+  } else if (autoStartEnd) {
+    for (const { name: nodeName } of parallel2) {
+      graph.addEdge(nodeName, END2);
+    }
+  }
+  return graph;
+}
+
+// src/langgraph/builders/conditional.ts
+function createConditionalRouter(config) {
+  const { routes, condition, description } = config;
+  if (Object.keys(routes).length === 0) {
+    throw new Error("Conditional router must have at least one route");
+  }
+  if (typeof condition !== "function") {
+    throw new Error("Conditional router must have a condition function");
+  }
+  return {
+    routes,
+    condition,
+    description
+  };
+}
+function createBinaryRouter(config) {
+  const { condition, ifTrue, ifFalse, description } = config;
+  return {
+    routes: {
+      true: ifTrue,
+      false: ifFalse
+    },
+    condition: (state) => condition(state) ? "true" : "false",
+    description
+  };
+}
+function createMultiRouter(config) {
+  const { discriminator, routes, default: defaultRoute, description } = config;
+  return {
+    routes,
+    condition: (state) => {
+      const key = discriminator(state);
+      if (key in routes) {
+        return key;
+      }
+      if (defaultRoute !== void 0) {
+        return defaultRoute;
+      }
+      throw new Error(`No route found for discriminator value: ${key}`);
+    },
+    description
+  };
+}
+
+// src/langgraph/builders/subgraph.ts
+import { StateGraph as StateGraph3 } from "@langchain/langgraph";
+function createSubgraph(stateSchema, builder) {
+  const graph = new StateGraph3(stateSchema);
+  const configured = builder(graph);
+  return configured.compile();
+}
+function composeGraphs(parentGraph, subgraph, options) {
+  const { name } = options;
+  parentGraph.addNode(name, subgraph);
+  return parentGraph;
+}
+
+// src/langgraph/patterns/retry.ts
+function calculateDelay(attempt, strategy, initialDelay, maxDelay) {
+  let delay;
+  switch (strategy) {
+    case "constant":
+      delay = initialDelay;
+      break;
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+  }
+  return Math.min(delay, maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withRetry(node, options = {}) {
+  const {
+    maxAttempts = 3,
+    backoff = "exponential",
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    onRetry,
+    shouldRetry = () => true
+  } = options;
+  return async (state) => {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await Promise.resolve(node(state));
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!shouldRetry(lastError)) {
+          throw lastError;
+        }
+        if (attempt === maxAttempts) {
+          throw lastError;
+        }
+        if (onRetry) {
+          onRetry(lastError, attempt);
+        }
+        const delay = calculateDelay(attempt, backoff, initialDelay, maxDelay);
+        await sleep(delay);
+      }
+    }
+    throw lastError || new Error("Retry failed");
+  };
+}
+
+// src/langgraph/patterns/error-handler.ts
+function withErrorHandler(node, options) {
+  const { onError, logError, rethrow = false } = options;
+  return async (state) => {
+    try {
+      return await Promise.resolve(node(state));
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (logError) {
+        logError(err, state);
+      }
+      const result = await Promise.resolve(onError(err, state));
+      if (rethrow) {
+        throw err;
+      }
+      return result;
+    }
+  };
+}
+
+// src/langgraph/patterns/timeout.ts
+var TimeoutError = class extends Error {
+  constructor(timeout2) {
+    super(`Node execution timed out after ${timeout2}ms`);
+    this.name = "TimeoutError";
+  }
+};
+function withTimeout(node, options) {
+  const { timeout: timeout2, onTimeout, logTimeout, throwOnTimeout = false } = options;
+  return async (state) => {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new TimeoutError(timeout2));
+      }, timeout2);
+    });
+    try {
+      return await Promise.race([Promise.resolve(node(state)), timeoutPromise]);
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        if (logTimeout) {
+          logTimeout(state);
+        }
+        if (throwOnTimeout) {
+          throw error;
+        }
+        return await Promise.resolve(onTimeout(state));
+      }
+      throw error;
+    }
+  };
+}
+
+// src/langgraph/persistence/checkpointer.ts
+import { MemorySaver } from "@langchain/langgraph";
+function createMemoryCheckpointer(options) {
+  return new MemorySaver();
+}
+async function createSqliteCheckpointer(options = {}) {
+  const { path = ":memory:", autoMigrate = true } = options;
+  try {
+    const { SqliteSaver } = await import("@langchain/langgraph-checkpoint-sqlite");
+    const checkpointer = SqliteSaver.fromConnString(path);
+    if (autoMigrate) {
+      await checkpointer.setup();
+    }
+    return checkpointer;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(
+        "SQLite checkpointer requires @langchain/langgraph-checkpoint-sqlite to be installed. Install it with: npm install @langchain/langgraph-checkpoint-sqlite"
+      );
+    }
+    throw error;
+  }
+}
+function isMemoryCheckpointer(checkpointer) {
+  return checkpointer instanceof MemorySaver;
+}
+
+// src/langgraph/persistence/thread.ts
+import { randomUUID } from "crypto";
+function generateThreadId(seed) {
+  if (seed && seed.length > 0) {
+    const hash = Buffer.from(seed).toString("base64").replace(/[^a-zA-Z0-9]/g, "");
+    return `thread-${hash}`;
+  }
+  return randomUUID();
+}
+function createThreadConfig(config = {}) {
+  const { threadId = generateThreadId(), checkpointId, checkpointNamespace, metadata } = config;
+  const runnableConfig = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  if (checkpointId) {
+    runnableConfig.configurable.checkpoint_id = checkpointId;
+  }
+  if (checkpointNamespace) {
+    runnableConfig.configurable.checkpoint_ns = checkpointNamespace;
+  }
+  if (metadata) {
+    runnableConfig.metadata = metadata;
+  }
+  return runnableConfig;
+}
+function createConversationConfig(config) {
+  const { userId, sessionId, metadata = {} } = config;
+  const threadId = sessionId ? generateThreadId(`${userId}-${sessionId}`) : generateThreadId(userId);
+  return createThreadConfig({
+    threadId,
+    metadata: {
+      ...metadata,
+      userId,
+      sessionId
+    }
+  });
+}
+
+// src/langgraph/persistence/utils.ts
+async function getCheckpointHistory(checkpointer, options) {
+  const { threadId, limit = 10, before } = options;
+  const config = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  if (before) {
+    config.configurable.checkpoint_id = before;
+  }
+  const checkpoints = [];
+  for await (const checkpoint of checkpointer.list(config, { limit })) {
+    checkpoints.push(checkpoint);
+  }
+  return checkpoints;
+}
+async function getLatestCheckpoint(checkpointer, options) {
+  const { threadId } = options;
+  const config = {
+    configurable: {
+      thread_id: threadId
+    }
+  };
+  const tuple = await checkpointer.getTuple(config);
+  return tuple || null;
+}
+async function clearThread(checkpointer, options) {
+  const { threadId } = options;
+  const checkpoints = await getCheckpointHistory(checkpointer, {
+    threadId,
+    limit: 1e3
+    // Get all checkpoints
+  });
+  if (checkpoints.length > 0) {
+    throw new Error(
+      "Clearing threads is not supported by the current checkpointer implementation. Consider using a new thread ID instead."
+    );
+  }
+}
+
+// src/langgraph/observability/langsmith.ts
+var globalConfig = null;
+function configureLangSmith(config) {
+  globalConfig = config;
+  if (config.apiKey) {
+    process.env.LANGSMITH_API_KEY = config.apiKey;
+  }
+  if (config.projectName) {
+    process.env.LANGSMITH_PROJECT = config.projectName;
+  }
+  if (config.tracingEnabled !== void 0) {
+    process.env.LANGSMITH_TRACING = config.tracingEnabled ? "true" : "false";
+  } else if (config.apiKey) {
+    process.env.LANGSMITH_TRACING = "true";
+  }
+  if (config.endpoint) {
+    process.env.LANGSMITH_ENDPOINT = config.endpoint;
+  }
+}
+function getLangSmithConfig() {
+  return globalConfig;
+}
+function isTracingEnabled() {
+  return process.env.LANGSMITH_TRACING === "true";
+}
+function withTracing(node, options) {
+  const { name, metadata, tags, runName } = options;
+  return async (state) => {
+    if (isTracingEnabled()) {
+      const result = await Promise.resolve(node(state));
+      return result;
+    }
+    return await Promise.resolve(node(state));
+  };
+}
+
+// src/langgraph/observability/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["DEBUG"] = "debug";
+  LogLevel2["INFO"] = "info";
+  LogLevel2["WARN"] = "warn";
+  LogLevel2["ERROR"] = "error";
+  return LogLevel2;
+})(LogLevel || {});
+var LOG_LEVEL_PRIORITY = {
+  ["debug" /* DEBUG */]: 0,
+  ["info" /* INFO */]: 1,
+  ["warn" /* WARN */]: 2,
+  ["error" /* ERROR */]: 3
+};
+var LoggerImpl = class _LoggerImpl {
+  name;
+  options;
+  context;
+  constructor(name, options = {}, context = {}) {
+    this.name = name;
+    this.context = context;
+    this.options = {
+      level: options.level ?? "info" /* INFO */,
+      format: options.format ?? "pretty",
+      destination: options.destination ?? process.stdout,
+      includeTimestamp: options.includeTimestamp ?? true,
+      includeContext: options.includeContext ?? true
+    };
+  }
+  debug(message, data) {
+    this.log("debug" /* DEBUG */, message, data);
+  }
+  info(message, data) {
+    this.log("info" /* INFO */, message, data);
+  }
+  warn(message, data) {
+    this.log("warn" /* WARN */, message, data);
+  }
+  error(message, data) {
+    this.log("error" /* ERROR */, message, data);
+  }
+  withContext(context) {
+    return new _LoggerImpl(this.name, this.options, { ...this.context, ...context });
+  }
+  log(level, message, data) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.options.level]) {
+      return;
+    }
+    const entry = {
+      level,
+      name: this.name,
+      message
+    };
+    if (this.options.includeTimestamp) {
+      entry.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (this.options.includeContext && Object.keys(this.context).length > 0) {
+      entry.context = this.context;
+    }
+    if (data) {
+      entry.data = data;
+    }
+    const output = this.format(entry);
+    this.options.destination.write(output + "\n");
+  }
+  format(entry) {
+    if (this.options.format === "json") {
+      return JSON.stringify(entry);
+    }
+    const parts = [];
+    if (entry.timestamp) {
+      parts.push(`[${entry.timestamp}]`);
+    }
+    parts.push(`[${entry.level.toUpperCase()}]`);
+    parts.push(`[${entry.name}]`);
+    parts.push(entry.message);
+    if (entry.context) {
+      parts.push(`context=${JSON.stringify(entry.context)}`);
+    }
+    if (entry.data) {
+      parts.push(`data=${JSON.stringify(entry.data)}`);
+    }
+    return parts.join(" ");
+  }
+};
+function createLogger(name, options) {
+  return new LoggerImpl(name, options);
+}
+
+// src/langgraph/observability/metrics.ts
+var MetricType = /* @__PURE__ */ ((MetricType2) => {
+  MetricType2["COUNTER"] = "counter";
+  MetricType2["GAUGE"] = "gauge";
+  MetricType2["HISTOGRAM"] = "histogram";
+  return MetricType2;
+})(MetricType || {});
+var MetricsImpl = class {
+  name;
+  metrics = [];
+  counters = /* @__PURE__ */ new Map();
+  constructor(name) {
+    this.name = name;
+  }
+  increment(name, value = 1, labels) {
+    const key = this.getKey(name, labels);
+    const current = this.counters.get(key) ?? 0;
+    this.counters.set(key, current + value);
+    this.record({
+      type: "counter" /* COUNTER */,
+      name: this.prefixName(name),
+      value: current + value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  decrement(name, value = 1, labels) {
+    this.increment(name, -value, labels);
+  }
+  gauge(name, value, labels) {
+    this.record({
+      type: "gauge" /* GAUGE */,
+      name: this.prefixName(name),
+      value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  histogram(name, value, labels) {
+    this.record({
+      type: "histogram" /* HISTOGRAM */,
+      name: this.prefixName(name),
+      value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  startTimer(name, labels) {
+    const startTime = Date.now();
+    return {
+      end: () => {
+        const duration = Date.now() - startTime;
+        this.histogram(name, duration, labels);
+        return duration;
+      }
+    };
+  }
+  getMetrics() {
+    return [...this.metrics];
+  }
+  clear() {
+    this.metrics = [];
+    this.counters.clear();
+  }
+  record(entry) {
+    this.metrics.push(entry);
+  }
+  prefixName(name) {
+    return `${this.name}.${name}`;
+  }
+  getKey(name, labels) {
+    const labelStr = labels ? JSON.stringify(labels) : "";
+    return `${name}:${labelStr}`;
+  }
+};
+function createMetrics(name) {
+  return new MetricsImpl(name);
+}
+function withMetrics(node, options) {
+  const {
+    name,
+    trackDuration = true,
+    trackErrors = true,
+    trackInvocations = true,
+    metrics = createMetrics(name)
+  } = options;
+  return async (state) => {
+    if (trackInvocations) {
+      metrics.increment(`${name}.invocations`);
+    }
+    const timer = trackDuration ? metrics.startTimer(`${name}.duration`) : null;
+    try {
+      const result = await Promise.resolve(node(state));
+      metrics.increment(`${name}.success`);
+      return result;
+    } catch (error) {
+      if (trackErrors) {
+        metrics.increment(`${name}.errors`);
+      }
+      throw error;
+    } finally {
+      if (timer) {
+        timer.end();
+      }
+    }
+  };
+}
+
+// src/langgraph/observability/errors.ts
+var AgentError = class _AgentError extends Error {
+  code;
+  node;
+  state;
+  metadata;
+  cause;
+  timestamp;
+  constructor(message, context = {}) {
+    super(message);
+    this.name = "AgentError";
+    this.code = context.code;
+    this.node = context.node;
+    this.state = context.state;
+    this.metadata = context.metadata;
+    this.cause = context.cause;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AgentError);
+    }
+  }
+  /**
+   * Convert error to JSON for logging/reporting
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      node: this.node,
+      state: this.state,
+      metadata: this.metadata,
+      timestamp: this.timestamp,
+      stack: this.stack,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : void 0
+    };
+  }
+  /**
+   * Get a human-readable string representation
+   */
+  toString() {
+    const parts = [`${this.name}: ${this.message}`];
+    if (this.code) {
+      parts.push(`Code: ${this.code}`);
+    }
+    if (this.node) {
+      parts.push(`Node: ${this.node}`);
+    }
+    if (this.cause) {
+      parts.push(`Caused by: ${this.cause.message}`);
+    }
+    return parts.join("\n");
+  }
+};
+var ErrorReporterImpl = class {
+  options;
+  constructor(options) {
+    this.options = {
+      onError: options.onError,
+      includeStackTrace: options.includeStackTrace ?? true,
+      includeState: options.includeState ?? false,
+      rethrow: options.rethrow ?? true
+    };
+  }
+  wrap(node, nodeName) {
+    return async (state) => {
+      try {
+        return await Promise.resolve(node(state));
+      } catch (error) {
+        const agentError = this.toAgentError(error, {
+          node: nodeName,
+          state: this.options.includeState ? state : void 0
+        });
+        await this.report(agentError);
+        if (this.options.rethrow) {
+          throw agentError;
+        }
+        return state;
+      }
+    };
+  }
+  async report(error, context) {
+    const agentError = this.toAgentError(error, context);
+    try {
+      await Promise.resolve(this.options.onError(agentError));
+    } catch (reportError) {
+      console.error("Error reporting failed:", reportError);
+    }
+  }
+  toAgentError(error, context) {
+    if (error instanceof AgentError) {
+      return error;
+    }
+    return new AgentError(error.message, {
+      ...context,
+      cause: error
+    });
+  }
+};
+function createErrorReporter(options) {
+  return new ErrorReporterImpl(options);
+}
+
+// src/langgraph/middleware/compose.ts
+function compose(...middleware) {
+  return (node) => {
+    return middleware.reduceRight(
+      (wrappedNode, mw) => mw(wrappedNode),
+      node
+    );
+  };
+}
+function composeWithOptions(options, ...middleware) {
+  const { reverse = false, name, catchErrors = true } = options;
+  return (node) => {
+    const orderedMiddleware = reverse ? [...middleware].reverse() : middleware;
+    let wrappedNode = orderedMiddleware.reduceRight(
+      (wrappedNode2, mw) => mw(wrappedNode2),
+      node
+    );
+    if (catchErrors) {
+      const originalNode = wrappedNode;
+      wrappedNode = async (state) => {
+        try {
+          return await Promise.resolve(originalNode(state));
+        } catch (error) {
+          const enhancedError = error instanceof Error ? error : new Error(String(error));
+          if (name) {
+            enhancedError.message = `[${name}] ${enhancedError.message}`;
+          }
+          throw enhancedError;
+        }
+      };
+    }
+    return wrappedNode;
+  };
+}
+var MiddlewareChain = class {
+  middleware = [];
+  options = {};
+  /**
+   * Add middleware to the chain.
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+  /**
+   * Set composition options.
+   */
+  withOptions(options) {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+  /**
+   * Build the middleware chain and apply it to a node.
+   */
+  build(node) {
+    if (this.middleware.length === 0) {
+      return node;
+    }
+    return composeWithOptions(this.options, ...this.middleware)(node);
+  }
+  /**
+   * Get the number of middleware in the chain.
+   */
+  get length() {
+    return this.middleware.length;
+  }
+};
+function chain() {
+  return new MiddlewareChain();
+}
+function createMiddlewareContext() {
+  return {
+    executionId: `exec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+    startTime: Date.now(),
+    data: {},
+    middlewareStack: []
+  };
+}
+
+// src/langgraph/middleware/logging.ts
+var withLogging = (options) => {
+  const {
+    logger: providedLogger,
+    name = "node",
+    level = "info",
+    logInput = true,
+    logOutput = true,
+    logDuration = true,
+    logErrors = true,
+    extractData,
+    onStart,
+    onComplete,
+    onError
+  } = options;
+  const logger = providedLogger || createLogger(name, { level });
+  return (node) => {
+    return async (state) => {
+      const startTime = Date.now();
+      try {
+        if (logInput) {
+          const data = extractData ? extractData(state) : { state };
+          logger.info("Node execution started", data);
+        }
+        if (onStart) {
+          onStart(state);
+        }
+        const result = await Promise.resolve(node(state));
+        const duration = Date.now() - startTime;
+        if (logOutput) {
+          const data = extractData ? extractData(result) : { result };
+          if (logDuration) {
+            logger.info(`Node execution completed (${duration}ms)`, data);
+          } else {
+            logger.info("Node execution completed", data);
+          }
+        }
+        if (onComplete) {
+          onComplete(state, result, duration);
+        }
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (logErrors) {
+          logger.error(`Node execution failed (${duration}ms)`, {
+            error: err.message,
+            stack: err.stack
+          });
+        }
+        if (onError) {
+          onError(err, duration);
+        }
+        throw error;
+      }
+    };
+  };
+};
+
+// src/langgraph/middleware/presets.ts
+function withRetry2(options) {
+  return (node) => withRetry(node, options);
+}
+function withErrorHandler2(options) {
+  return (node) => withErrorHandler(node, options);
+}
+function withTimeout2(options) {
+  return (node) => withTimeout(node, options);
+}
+function withMetrics2(options) {
+  return (node) => withMetrics(node, options);
+}
+function withTracing2(options) {
+  return (node) => withTracing(node, options);
+}
+function withLogging2(options) {
+  return (node) => withLogging(options)(node);
+}
+function production(node, options) {
+  const {
+    nodeName,
+    logger,
+    enableMetrics = true,
+    enableTracing = true,
+    enableRetry = true,
+    timeout: timeout2 = 3e4,
+    retryOptions = {},
+    errorOptions = {}
+  } = options;
+  const actualLogger = logger || createLogger(nodeName, { level: "info" /* INFO */ });
+  const middleware = [];
+  middleware.push(
+    withLogging2({
+      logger: actualLogger,
+      name: nodeName,
+      logInput: false,
+      // Don't log input in production by default
+      logOutput: false,
+      // Don't log output in production by default
+      logDuration: true,
+      logErrors: true
+    })
+  );
+  middleware.push(
+    withErrorHandler2({
+      onError: (error, state) => {
+        return state;
+      },
+      ...errorOptions
+    })
+  );
+  if (enableRetry) {
+    middleware.push(
+      withRetry2({
+        maxAttempts: 3,
+        backoff: "exponential",
+        initialDelay: 1e3,
+        ...retryOptions
+      })
+    );
+  }
+  middleware.push(
+    withTimeout2({
+      timeout: timeout2,
+      onTimeout: (state) => {
+        return state;
+      }
+    })
+  );
+  if (enableMetrics) {
+    middleware.push(
+      withMetrics2({
+        name: nodeName,
+        trackDuration: true,
+        trackErrors: true,
+        trackInvocations: true
+      })
+    );
+  }
+  if (enableTracing) {
+    middleware.push(
+      withTracing2({
+        name: nodeName,
+        metadata: { preset: "production" }
+      })
+    );
+  }
+  return compose(...middleware)(node);
+}
+function development(node, options) {
+  const {
+    nodeName,
+    verbose = true,
+    logger
+  } = options;
+  const actualLogger = logger || createLogger(nodeName, { level: "debug" /* DEBUG */ });
+  return withLogging2({
+    logger: actualLogger,
+    name: nodeName,
+    logInput: verbose,
+    logOutput: verbose,
+    logDuration: true,
+    logErrors: true
+  })(node);
+}
+function testing(node, options) {
+  const {
+    nodeName,
+    mockResponse,
+    simulateError,
+    delay = 0,
+    trackInvocations = false
+  } = options;
+  const invocations = [];
+  const wrappedNode = async (state) => {
+    if (trackInvocations) {
+      invocations.push(state);
+    }
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    if (simulateError) {
+      throw simulateError;
+    }
+    if (mockResponse) {
+      return { ...state, ...mockResponse };
+    }
+    return await Promise.resolve(node(state));
+  };
+  wrappedNode.invocations = invocations;
+  return wrappedNode;
+}
+var presets = {
+  production,
+  development,
+  testing
+};
+
+// src/streaming/transformers.ts
+async function* chunk(stream, options) {
+  const { size } = options;
+  if (size <= 0) {
+    throw new Error("Chunk size must be greater than 0");
+  }
+  let buffer = [];
+  for await (const item of stream) {
+    buffer.push(item);
+    if (buffer.length >= size) {
+      yield buffer;
+      buffer = [];
+    }
+  }
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}
+async function* batch(stream, options) {
+  const { maxSize, maxWait } = options;
+  if (maxSize <= 0) {
+    throw new Error("Batch maxSize must be greater than 0");
+  }
+  if (maxWait <= 0) {
+    throw new Error("Batch maxWait must be greater than 0");
+  }
+  let buffer = [];
+  let timeoutId = null;
+  const flushBuffer = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (buffer.length === 0) {
+      return null;
+    }
+    const result = buffer;
+    buffer = [];
+    return result;
+  };
+  try {
+    for await (const item of stream) {
+      buffer.push(item);
+      if (buffer.length >= maxSize) {
+        const result = flushBuffer();
+        if (result) {
+          yield result;
+        }
+      } else if (!timeoutId) {
+        timeoutId = setTimeout(() => {
+        }, maxWait);
+      }
+    }
+    const remaining = flushBuffer();
+    if (remaining) {
+      yield remaining;
+    }
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+async function* throttle(stream, options) {
+  const { rate, per } = options;
+  if (rate <= 0) {
+    throw new Error("Throttle rate must be greater than 0");
+  }
+  if (per <= 0) {
+    throw new Error("Throttle per must be greater than 0");
+  }
+  const interval = per / rate;
+  let lastEmit = 0;
+  for await (const item of stream) {
+    const now = Date.now();
+    const timeSinceLastEmit = now - lastEmit;
+    if (timeSinceLastEmit < interval) {
+      await new Promise((resolve) => setTimeout(resolve, interval - timeSinceLastEmit));
+    }
+    lastEmit = Date.now();
+    yield item;
+  }
+}
+
+// src/streaming/aggregators.ts
+async function collect(stream) {
+  const items = [];
+  for await (const item of stream) {
+    items.push(item);
+  }
+  return items;
+}
+async function reduce(stream, reducer, initialValue) {
+  let accumulator = initialValue;
+  for await (const item of stream) {
+    accumulator = reducer(accumulator, item);
+  }
+  return accumulator;
+}
+async function* merge(streams) {
+  if (streams.length === 0) {
+    return;
+  }
+  const iterators = streams.map((stream) => stream[Symbol.asyncIterator]());
+  const active = new Set(iterators);
+  const promises = /* @__PURE__ */ new Map();
+  const createPromise = (iterator) => {
+    return iterator.next().then((result) => ({ iterator, result }));
+  };
+  for (const iterator of iterators) {
+    promises.set(iterator, createPromise(iterator));
+  }
+  while (active.size > 0) {
+    const { iterator, result } = await Promise.race(promises.values());
+    if (result.done) {
+      active.delete(iterator);
+      promises.delete(iterator);
+    } else {
+      yield result.value;
+      promises.set(iterator, createPromise(iterator));
+    }
+  }
+}
+async function* filter(stream, predicate) {
+  for await (const item of stream) {
+    if (await predicate(item)) {
+      yield item;
+    }
+  }
+}
+async function* map(stream, mapper) {
+  for await (const item of stream) {
+    yield await mapper(item);
+  }
+}
+async function* take(stream, count) {
+  if (count <= 0) {
+    return;
+  }
+  let taken = 0;
+  for await (const item of stream) {
+    yield item;
+    taken++;
+    if (taken >= count) {
+      break;
+    }
+  }
+}
+
+// src/streaming/progress.ts
+function createProgressTracker(options) {
+  const { total, onProgress, onComplete, onCancel } = options;
+  if (total <= 0) {
+    throw new Error("Total must be greater than 0");
+  }
+  let current = 0;
+  let startTime = 0;
+  let cancelled = false;
+  const calculateProgress = () => {
+    const elapsed = Date.now() - startTime;
+    const percentage = Math.min(100, current / total * 100);
+    let eta = 0;
+    if (current > 0 && current < total) {
+      const timePerItem = elapsed / current;
+      const remaining = total - current;
+      eta = Math.round(timePerItem * remaining / 1e3);
+    }
+    return {
+      current,
+      total,
+      percentage: Math.round(percentage * 100) / 100,
+      // Round to 2 decimal places
+      eta,
+      startTime,
+      elapsed
+    };
+  };
+  return {
+    start() {
+      if (startTime > 0) {
+        throw new Error("Progress tracker already started");
+      }
+      startTime = Date.now();
+      current = 0;
+      cancelled = false;
+    },
+    update(newCurrent) {
+      if (startTime === 0) {
+        throw new Error("Progress tracker not started");
+      }
+      if (cancelled) {
+        throw new Error("Progress tracker cancelled");
+      }
+      if (newCurrent < 0) {
+        throw new Error("Current progress cannot be negative");
+      }
+      if (newCurrent > total) {
+        newCurrent = total;
+      }
+      current = newCurrent;
+      if (onProgress) {
+        onProgress(calculateProgress());
+      }
+    },
+    complete() {
+      if (startTime === 0) {
+        throw new Error("Progress tracker not started");
+      }
+      if (cancelled) {
+        throw new Error("Progress tracker cancelled");
+      }
+      current = total;
+      const progress = calculateProgress();
+      if (onProgress) {
+        onProgress(progress);
+      }
+      if (onComplete) {
+        onComplete(progress);
+      }
+    },
+    cancel() {
+      if (startTime === 0) {
+        throw new Error("Progress tracker not started");
+      }
+      if (cancelled) {
+        return;
+      }
+      cancelled = true;
+      if (onCancel) {
+        onCancel();
+      }
+    },
+    getProgress() {
+      if (startTime === 0) {
+        throw new Error("Progress tracker not started");
+      }
+      return calculateProgress();
+    },
+    isCancelled() {
+      return cancelled;
+    }
+  };
+}
+
+// src/streaming/sse.ts
+function formatSSEEvent(event) {
+  const lines = [];
+  if (event.id) {
+    lines.push(`id: ${event.id}`);
+  }
+  if (event.event) {
+    lines.push(`event: ${event.event}`);
+  }
+  if (event.retry !== void 0) {
+    lines.push(`retry: ${event.retry}`);
+  }
+  const dataLines = event.data.split("\n");
+  for (const line of dataLines) {
+    lines.push(`data: ${line}`);
+  }
+  return lines.join("\n") + "\n\n";
+}
+function createSSEFormatter(options = {}) {
+  const { eventTypes = {}, heartbeat = 0, retry: retry2 } = options;
+  return {
+    async *format(stream) {
+      let heartbeatInterval = null;
+      let lastEventId = 0;
+      try {
+        if (heartbeat > 0) {
+          heartbeatInterval = setInterval(() => {
+          }, heartbeat);
+        }
+        if (retry2 !== void 0) {
+          yield formatSSEEvent({ data: "", retry: retry2 });
+        }
+        for await (const item of stream) {
+          let event;
+          let matched = false;
+          for (const [type, mapper] of Object.entries(eventTypes)) {
+            try {
+              const mapped = mapper(item);
+              if (mapped) {
+                event = {
+                  ...mapped,
+                  id: String(++lastEventId)
+                };
+                matched = true;
+                break;
+              }
+            } catch {
+            }
+          }
+          if (!matched) {
+            event = {
+              data: JSON.stringify(item),
+              id: String(++lastEventId)
+            };
+          }
+          yield formatSSEEvent(event);
+          if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+            heartbeatInterval = setInterval(() => {
+            }, heartbeat);
+          }
+        }
+      } finally {
+        if (heartbeatInterval) {
+          clearInterval(heartbeatInterval);
+        }
+      }
+    }
+  };
+}
+function createHeartbeat() {
+  return ": heartbeat\n\n";
+}
+function parseSSEEvent(eventString) {
+  const lines = eventString.trim().split("\n");
+  const event = { data: "" };
+  for (const line of lines) {
+    if (line.startsWith("id:")) {
+      event.id = line.slice(3).trim();
+    } else if (line.startsWith("event:")) {
+      event.event = line.slice(6).trim();
+    } else if (line.startsWith("retry:")) {
+      event.retry = parseInt(line.slice(6).trim(), 10);
+    } else if (line.startsWith("data:")) {
+      const data = line.slice(5).trim();
+      event.data = event.data ? `${event.data}
+${data}` : data;
+    }
+  }
+  return event.data !== void 0 ? event : null;
+}
+
+// src/streaming/websocket.ts
+function createWebSocketHandler(options) {
+  const { onConnect, onMessage, onError, onClose, heartbeat = 0 } = options;
+  return function handler(ws, req) {
+    let heartbeatInterval = null;
+    let isAlive = true;
+    if (heartbeat > 0) {
+      heartbeatInterval = setInterval(() => {
+        if (!isAlive) {
+          if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+          }
+          ws.terminate();
+          return;
+        }
+        isAlive = false;
+        ws.ping();
+      }, heartbeat);
+      ws.on("pong", () => {
+        isAlive = true;
+      });
+    }
+    if (onConnect) {
+      try {
+        onConnect(ws, req);
+      } catch (error) {
+        if (onError) {
+          onError(ws, error);
+        }
+      }
+    }
+    ws.on("message", async (data) => {
+      try {
+        let message;
+        if (typeof data === "string") {
+          try {
+            message = JSON.parse(data);
+          } catch {
+            message = data;
+          }
+        } else {
+          message = data;
+        }
+        if (onMessage) {
+          await onMessage(ws, message);
+        }
+      } catch (error) {
+        if (onError) {
+          onError(ws, error);
+        }
+      }
+    });
+    ws.on("error", (error) => {
+      if (onError) {
+        onError(ws, error);
+      }
+    });
+    ws.on("close", (code, reason) => {
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+      }
+      if (onClose) {
+        onClose(ws, code, reason);
+      }
+    });
+  };
+}
+function sendMessage(ws, message) {
+  if (ws.readyState === 1) {
+    ws.send(JSON.stringify(message));
+  }
+}
+function broadcast(clients, message) {
+  const data = JSON.stringify(message);
+  for (const client of clients) {
+    if (client.readyState === 1) {
+      client.send(data);
+    }
+  }
+}
+function createMessage(type, data, error) {
+  return { type, data, error };
+}
+
+// src/resources/pool.ts
+var ConnectionPool = class {
+  constructor(options) {
+    this.options = options;
+    const poolConfig = options.pool || {};
+    const min = poolConfig.min || 0;
+    if (min > 0) {
+      this.initialize(min).catch((error) => {
+        console.error("Failed to initialize pool:", error);
+      });
+    }
+    const evictionInterval = poolConfig.evictionInterval || 6e4;
+    this.evictionTimer = setInterval(() => {
+      this.evictIdleConnections().catch((error) => {
+        console.error("Failed to evict idle connections:", error);
+      });
+    }, evictionInterval);
+    const healthCheck = options.healthCheck || {};
+    if (healthCheck.enabled) {
+      const interval = healthCheck.interval || 3e4;
+      this.healthCheckTimer = setInterval(() => {
+        this.performHealthChecks().catch((error) => {
+          console.error("Health check failed:", error);
+          options.onHealthCheckFail?.(error);
+        });
+      }, interval);
+    }
+  }
+  connections = [];
+  pending = [];
+  stats = {
+    size: 0,
+    available: 0,
+    pending: 0,
+    acquired: 0,
+    created: 0,
+    destroyed: 0,
+    healthChecksPassed: 0,
+    healthChecksFailed: 0
+  };
+  evictionTimer;
+  healthCheckTimer;
+  draining = false;
+  async initialize(count) {
+    const promises = Array.from({ length: count }, () => this.createConnection());
+    await Promise.all(promises);
+  }
+  async createConnection() {
+    const connection = await this.options.factory();
+    this.connections.push({
+      connection,
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      inUse: false
+    });
+    this.stats.created++;
+    this.stats.size++;
+    this.stats.available++;
+    return connection;
+  }
+  async destroyConnection(pooled) {
+    const index = this.connections.indexOf(pooled);
+    if (index !== -1) {
+      this.connections.splice(index, 1);
+    }
+    if (this.options.destroyer) {
+      await this.options.destroyer(pooled.connection);
+    }
+    this.options.onDestroy?.(pooled.connection);
+    this.stats.destroyed++;
+    this.stats.size--;
+    if (!pooled.inUse) {
+      this.stats.available--;
+    }
+  }
+  async acquire() {
+    if (this.draining) {
+      throw new Error("Pool is draining");
+    }
+    const available = this.connections.find((c) => !c.inUse);
+    if (available) {
+      available.inUse = true;
+      available.lastUsedAt = Date.now();
+      this.stats.available--;
+      this.stats.acquired++;
+      this.options.onAcquire?.(available.connection);
+      return available.connection;
+    }
+    const poolConfig = this.options.pool || {};
+    const max = poolConfig.max || 10;
+    if (this.connections.length < max) {
+      const connection = await this.createConnection();
+      const pooled = this.connections.find((c) => c.connection === connection);
+      pooled.inUse = true;
+      this.stats.available--;
+      this.stats.acquired++;
+      this.options.onAcquire?.(connection);
+      return connection;
+    }
+    return new Promise((resolve, reject) => {
+      const timeout2 = poolConfig.acquireTimeout || 3e4;
+      const timer = setTimeout(() => {
+        const index = this.pending.findIndex((p) => p.resolve === resolve);
+        if (index !== -1) {
+          this.pending.splice(index, 1);
+          this.stats.pending--;
+        }
+        reject(new Error("Acquire timeout"));
+      }, timeout2);
+      this.pending.push({ resolve, reject, timeout: timer });
+      this.stats.pending++;
+    });
+  }
+  async release(connection) {
+    const pooled = this.connections.find((c) => c.connection === connection);
+    if (!pooled) {
+      throw new Error("Connection not found in pool");
+    }
+    if (!pooled.inUse) {
+      throw new Error("Connection is not in use");
+    }
+    pooled.inUse = false;
+    pooled.lastUsedAt = Date.now();
+    this.stats.available++;
+    this.stats.acquired--;
+    this.options.onRelease?.(connection);
+    const pending = this.pending.shift();
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.stats.pending--;
+      pooled.inUse = true;
+      this.stats.available--;
+      this.stats.acquired++;
+      this.options.onAcquire?.(connection);
+      pending.resolve(connection);
+    }
+  }
+  async evictIdleConnections() {
+    const poolConfig = this.options.pool || {};
+    const idleTimeout = poolConfig.idleTimeout || 6e4;
+    const min = poolConfig.min || 0;
+    const now = Date.now();
+    const toEvict = this.connections.filter(
+      (c) => !c.inUse && now - c.lastUsedAt > idleTimeout && this.connections.length > min
+    );
+    for (const pooled of toEvict) {
+      await this.destroyConnection(pooled);
+    }
+  }
+  async performHealthChecks() {
+    if (!this.options.validator) {
+      return;
+    }
+    const healthCheck = this.options.healthCheck || {};
+    const timeout2 = healthCheck.timeout || 5e3;
+    const retries = healthCheck.retries || 1;
+    for (const pooled of this.connections) {
+      if (pooled.inUse) {
+        continue;
+      }
+      let healthy = false;
+      for (let i = 0; i < retries; i++) {
+        try {
+          const result = await Promise.race([
+            this.options.validator(pooled.connection),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout2)
+            )
+          ]);
+          if (result) {
+            healthy = true;
+            break;
+          }
+        } catch (error) {
+        }
+      }
+      if (healthy) {
+        this.stats.healthChecksPassed++;
+      } else {
+        this.stats.healthChecksFailed++;
+        await this.destroyConnection(pooled);
+      }
+    }
+  }
+  async drain() {
+    this.draining = true;
+    for (const pending of this.pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Pool is draining"));
+    }
+    this.pending = [];
+    this.stats.pending = 0;
+    while (this.connections.some((c) => c.inUse)) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  async clear() {
+    if (this.evictionTimer) {
+      clearInterval(this.evictionTimer);
+      this.evictionTimer = void 0;
+    }
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+    const connections = [...this.connections];
+    for (const pooled of connections) {
+      await this.destroyConnection(pooled);
+    }
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+};
+function createConnectionPool(options) {
+  return new ConnectionPool(options);
+}
+
+// src/resources/database-pool.ts
+var MockDatabaseConnection = class {
+  constructor(config) {
+    this.config = config;
+  }
+  closed = false;
+  async query(sql, params) {
+    if (this.closed) {
+      throw new Error("Connection is closed");
+    }
+    return [];
+  }
+  async execute(sql, params) {
+    if (this.closed) {
+      throw new Error("Connection is closed");
+    }
+  }
+  async close() {
+    this.closed = true;
+  }
+};
+var DatabasePool = class {
+  constructor(options) {
+    this.options = options;
+    const healthCheckQuery = options.healthCheck?.query || "SELECT 1";
+    this.pool = createConnectionPool({
+      factory: async () => {
+        const connection = new MockDatabaseConnection(options.config);
+        options.onConnect?.(connection);
+        return connection;
+      },
+      destroyer: async (connection) => {
+        await connection.close();
+        options.onDisconnect?.(connection);
+      },
+      validator: async (connection) => {
+        try {
+          await connection.query(healthCheckQuery);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      pool: options.pool,
+      healthCheck: options.healthCheck
+    });
+  }
+  pool;
+  async acquire() {
+    return this.pool.acquire();
+  }
+  async release(connection) {
+    return this.pool.release(connection);
+  }
+  async query(sql, params) {
+    const connection = await this.acquire();
+    try {
+      return await connection.query(sql, params);
+    } finally {
+      await this.release(connection);
+    }
+  }
+  async execute(sql, params) {
+    const connection = await this.acquire();
+    try {
+      await connection.execute(sql, params);
+    } finally {
+      await this.release(connection);
+    }
+  }
+  async drain() {
+    return this.pool.drain();
+  }
+  async clear() {
+    return this.pool.clear();
+  }
+  getStats() {
+    return this.pool.getStats();
+  }
+};
+function createDatabasePool(options) {
+  return new DatabasePool(options);
+}
+
+// src/resources/http-pool.ts
+var MockHttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  closed = false;
+  async get(url, config) {
+    return this.request({ ...config, url, method: "GET" });
+  }
+  async post(url, data, config) {
+    return this.request({ ...config, url, method: "POST", data });
+  }
+  async put(url, data, config) {
+    return this.request({ ...config, url, method: "PUT", data });
+  }
+  async delete(url, config) {
+    return this.request({ ...config, url, method: "DELETE" });
+  }
+  async request(config) {
+    if (this.closed) {
+      throw new Error("Client is closed");
+    }
+    return {
+      data: {},
+      status: 200,
+      statusText: "OK",
+      headers: {}
+    };
+  }
+  async close() {
+    this.closed = true;
+  }
+};
+var HttpPool = class {
+  constructor(options) {
+    this.options = options;
+    const healthCheckEndpoint = options.healthCheck?.endpoint || "/health";
+    const healthCheckMethod = options.healthCheck?.method || "GET";
+    this.pool = createConnectionPool({
+      factory: async () => {
+        const client = new MockHttpClient(options.config);
+        options.onConnect?.(client);
+        return client;
+      },
+      destroyer: async (client) => {
+        await client.close();
+        options.onDisconnect?.(client);
+      },
+      validator: async (client) => {
+        try {
+          const response = await client.request({
+            url: healthCheckEndpoint,
+            method: healthCheckMethod
+          });
+          return response.status >= 200 && response.status < 300;
+        } catch {
+          return false;
+        }
+      },
+      pool: options.pool,
+      healthCheck: options.healthCheck
+    });
+  }
+  pool;
+  async acquire() {
+    return this.pool.acquire();
+  }
+  async release(client) {
+    return this.pool.release(client);
+  }
+  async request(config) {
+    const client = await this.acquire();
+    try {
+      return await client.request(config);
+    } finally {
+      await this.release(client);
+    }
+  }
+  async drain() {
+    return this.pool.drain();
+  }
+  async clear() {
+    return this.pool.clear();
+  }
+  getStats() {
+    return this.pool.getStats();
+  }
+};
+function createHttpPool(options) {
+  return new HttpPool(options);
+}
+
+// src/resources/memory.ts
+var MemoryManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  cleanupHandlers = /* @__PURE__ */ new Map();
+  checkTimer;
+  leakDetectionTimer;
+  previousMemory;
+  running = false;
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    const interval = this.options.checkInterval || 1e4;
+    this.checkTimer = setInterval(() => {
+      this.checkMemory();
+    }, interval);
+    const leakDetection = this.options.leakDetection || {};
+    if (leakDetection.enabled) {
+      const sampleInterval = leakDetection.sampleInterval || 6e4;
+      this.leakDetectionTimer = setInterval(() => {
+        this.detectLeaks();
+      }, sampleInterval);
+    }
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+    if (this.leakDetectionTimer) {
+      clearInterval(this.leakDetectionTimer);
+      this.leakDetectionTimer = void 0;
+    }
+  }
+  registerCleanup(name, handler) {
+    this.cleanupHandlers.set(name, handler);
+  }
+  unregisterCleanup(name) {
+    this.cleanupHandlers.delete(name);
+  }
+  async cleanup(name) {
+    if (name) {
+      const handler = this.cleanupHandlers.get(name);
+      if (handler) {
+        await handler();
+      }
+    } else {
+      for (const handler of this.cleanupHandlers.values()) {
+        await handler();
+      }
+    }
+  }
+  getStats() {
+    const memUsage = process.memoryUsage();
+    const total = this.options.maxMemory || memUsage.heapTotal;
+    const used = memUsage.heapUsed;
+    return {
+      used,
+      total,
+      percentage: used / total * 100,
+      heapUsed: memUsage.heapUsed,
+      heapTotal: memUsage.heapTotal,
+      external: memUsage.external,
+      arrayBuffers: memUsage.arrayBuffers
+    };
+  }
+  forceGC() {
+    if (global.gc) {
+      global.gc();
+    } else {
+      console.warn("Garbage collection is not exposed. Run with --expose-gc flag.");
+    }
+  }
+  checkMemory() {
+    const stats = this.getStats();
+    const threshold = this.options.thresholdPercentage || 80;
+    if (stats.percentage >= threshold) {
+      this.options.onThreshold?.(stats);
+    }
+    if (this.options.maxMemory && stats.used >= this.options.maxMemory) {
+      this.options.onLimit?.(stats).catch((error) => {
+        console.error("Error in onLimit handler:", error);
+      });
+    }
+  }
+  detectLeaks() {
+    const stats = this.getStats();
+    if (this.previousMemory) {
+      const growth = stats.used - this.previousMemory.used;
+      const growthPercentage = growth / this.previousMemory.used * 100;
+      const threshold = this.options.leakDetection?.growthThreshold || 10;
+      if (growthPercentage > threshold) {
+        this.options.onLeak?.(stats);
+      }
+    }
+    this.previousMemory = stats;
+  }
+};
+function createMemoryManager(options) {
+  return new MemoryManager(options);
+}
+
+// src/resources/batch.ts
+var BatchProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  pending = [];
+  timer;
+  processing = false;
+  stats = {
+    totalBatches: 0,
+    totalItems: 0,
+    averageBatchSize: 0,
+    averageWaitTime: 0,
+    successfulBatches: 0,
+    failedBatches: 0
+  };
+  add(input) {
+    return new Promise((resolve, reject) => {
+      this.pending.push({
+        input,
+        resolve,
+        reject,
+        addedAt: Date.now()
+      });
+      if (!this.timer) {
+        this.timer = setTimeout(() => {
+          this.processBatch();
+        }, this.options.maxWaitTime);
+      }
+      if (this.pending.length >= this.options.maxBatchSize) {
+        this.processBatch();
+      }
+    });
+  }
+  async flush() {
+    if (this.pending.length > 0) {
+      await this.processBatch();
+    }
+  }
+  async processBatch() {
+    if (this.processing || this.pending.length === 0) {
+      return;
+    }
+    this.processing = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const batchSize = Math.min(this.pending.length, this.options.maxBatchSize);
+    const batch2 = this.pending.splice(0, batchSize);
+    const inputs = batch2.map((item) => item.input);
+    const now = Date.now();
+    const waitTimes = batch2.map((item) => now - item.addedAt);
+    const avgWaitTime = waitTimes.reduce((sum, time) => sum + time, 0) / waitTimes.length;
+    this.stats.totalBatches++;
+    this.stats.totalItems += batch2.length;
+    this.stats.averageBatchSize = (this.stats.averageBatchSize * (this.stats.totalBatches - 1) + batch2.length) / this.stats.totalBatches;
+    this.stats.averageWaitTime = (this.stats.averageWaitTime * (this.stats.totalBatches - 1) + avgWaitTime) / this.stats.totalBatches;
+    this.options.onBatchStart?.(inputs);
+    try {
+      const results = await this.options.processor(inputs);
+      if (results.length !== batch2.length) {
+        throw new Error(
+          `Processor returned ${results.length} results for ${batch2.length} inputs`
+        );
+      }
+      for (let i = 0; i < batch2.length; i++) {
+        batch2[i].resolve(results[i]);
+      }
+      this.stats.successfulBatches++;
+      this.options.onBatchComplete?.(inputs, results);
+    } catch (error) {
+      this.stats.failedBatches++;
+      this.options.onBatchError?.(inputs, error);
+      for (const item of batch2) {
+        if (this.options.onItemError) {
+          const fallback = this.options.onItemError(item.input, error);
+          if (fallback !== void 0) {
+            item.resolve(fallback);
+          } else {
+            item.reject(error);
+          }
+        } else {
+          item.reject(error);
+        }
+      }
+    } finally {
+      this.processing = false;
+      if (this.pending.length > 0) {
+        this.timer = setTimeout(() => {
+          this.processBatch();
+        }, this.options.maxWaitTime);
+      }
+    }
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  getPendingCount() {
+    return this.pending.length;
+  }
+};
+function createBatchProcessor(options) {
+  return new BatchProcessor(options);
+}
+
+// src/resources/circuit-breaker.ts
+var CircuitBreaker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  state = "closed";
+  failures = 0;
+  successes = 0;
+  totalCalls = 0;
+  stateChanges = 0;
+  lastFailureTime;
+  lastSuccessTime;
+  resetTimer;
+  callHistory = [];
+  halfOpenAttempts = 0;
+  async execute(fn) {
+    if (this.state === "open") {
+      throw new Error("Circuit breaker is open");
+    }
+    if (this.state === "half-open") {
+      const maxAttempts = this.options.halfOpenRequests || 1;
+      if (this.halfOpenAttempts >= maxAttempts) {
+        throw new Error("Circuit breaker is half-open and at capacity");
+      }
+      this.halfOpenAttempts++;
+    }
+    this.totalCalls++;
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  wrap(fn) {
+    return async (...args) => {
+      return this.execute(() => fn(...args));
+    };
+  }
+  onSuccess() {
+    this.successes++;
+    this.lastSuccessTime = Date.now();
+    this.recordCall(true);
+    this.options.onSuccess?.();
+    if (this.state === "half-open") {
+      this.transitionTo("closed");
+      this.failures = 0;
+      this.halfOpenAttempts = 0;
+    }
+  }
+  onFailure(error) {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    this.recordCall(false);
+    this.options.onFailure?.(error);
+    const shouldTrip = this.options.shouldTrip?.(error) ?? true;
+    if (!shouldTrip) {
+      return;
+    }
+    if (this.state === "half-open") {
+      this.transitionTo("open");
+      this.halfOpenAttempts = 0;
+      this.scheduleReset();
+    } else if (this.state === "closed") {
+      const recentFailures = this.getRecentFailures();
+      if (recentFailures >= this.options.failureThreshold) {
+        this.transitionTo("open");
+        this.scheduleReset();
+      }
+    }
+  }
+  recordCall(success) {
+    this.callHistory.push({
+      timestamp: Date.now(),
+      success
+    });
+    const monitoringPeriod = this.options.monitoringPeriod || 6e4;
+    const cutoff = Date.now() - monitoringPeriod;
+    this.callHistory = this.callHistory.filter((record) => record.timestamp >= cutoff);
+  }
+  getRecentFailures() {
+    return this.callHistory.filter((record) => !record.success).length;
+  }
+  scheduleReset() {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+    }
+    this.resetTimer = setTimeout(() => {
+      this.transitionTo("half-open");
+      this.halfOpenAttempts = 0;
+    }, this.options.resetTimeout);
+  }
+  transitionTo(newState) {
+    const previousState = this.state;
+    if (previousState === newState) {
+      return;
+    }
+    this.state = newState;
+    this.stateChanges++;
+    this.options.onStateChange?.(newState, previousState);
+  }
+  getState() {
+    return this.state;
+  }
+  getStats() {
+    return {
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      totalCalls: this.totalCalls,
+      failureRate: this.totalCalls > 0 ? this.failures / this.totalCalls : 0,
+      lastFailureTime: this.lastFailureTime,
+      lastSuccessTime: this.lastSuccessTime,
+      stateChanges: this.stateChanges
+    };
+  }
+  reset() {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+    this.halfOpenAttempts = 0;
+    this.callHistory = [];
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = void 0;
+    }
+  }
+};
+function createCircuitBreaker(options) {
+  return new CircuitBreaker(options);
+}
+export {
+  AgentError,
+  BatchProcessor,
+  CircuitBreaker,
+  ConnectionPool,
+  DatabasePool,
+  HttpPool,
+  LogLevel,
+  ManagedTool,
+  MemoryManager,
+  MetricType,
+  MiddlewareChain,
+  MissingDescriptionError,
+  RegistryEvent,
+  TimeoutError,
+  ToolBuilder,
+  ToolCategory,
+  ToolCategorySchema,
+  ToolExampleSchema,
+  ToolMetadataSchema,
+  ToolNameSchema,
+  ToolRegistry,
+  batch,
+  broadcast,
+  cache,
+  chain,
+  chunk,
+  clearThread,
+  collect,
+  compose,
+  composeGraphs,
+  composeTool,
+  composeWithOptions,
+  conditional,
+  configureLangSmith,
+  createBatchProcessor,
+  createBinaryRouter,
+  createCircuitBreaker,
+  createConditionalRouter,
+  createConnectionPool,
+  createConversationConfig,
+  createDatabasePool,
+  createErrorReporter,
+  createHeartbeat,
+  createHttpPool,
+  createLogger,
+  createManagedTool,
+  createMemoryCheckpointer,
+  createMemoryManager,
+  createMessage,
+  createMetrics,
+  createMiddlewareContext,
+  createMockTool,
+  createMultiRouter,
+  createParallelWorkflow,
+  createProgressTracker,
+  createSSEFormatter,
+  createSequentialWorkflow,
+  createSqliteCheckpointer,
+  createStateAnnotation,
+  createSubgraph,
+  createThreadConfig,
+  createTool,
+  createToolExecutor,
+  createToolSimulator,
+  createToolUnsafe,
+  createWebSocketHandler,
+  development,
+  filter,
+  generateThreadId,
+  getCheckpointHistory,
+  getLangSmithConfig,
+  getLatestCheckpoint,
+  getMissingDescriptions,
+  getToolDescription,
+  getToolJsonSchema,
+  isMemoryCheckpointer,
+  isTracingEnabled,
+  map,
+  merge,
+  mergeState,
+  parallel,
+  parseSSEEvent,
+  presets,
+  production,
+  reduce,
+  retry,
+  safeValidateSchemaDescriptions,
+  sendMessage,
+  sequential,
+  sequentialBuilder,
+  take,
+  testing,
+  throttle,
+  timeout,
+  toLangChainTool,
+  toLangChainTools,
+  toolBuilder,
+  validateSchemaDescriptions,
+  validateState,
+  validateTool,
+  validateToolMetadata,
+  validateToolName,
+  withErrorHandler,
+  withMetrics,
+  withRetry,
+  withTimeout,
+  withTracing
+};