agent-toolbelt 0.1.0

package/README.md

@@ -0,0 +1,182 @@
+# agent-toolbelt
+
+Official SDK for [Agent Toolbelt](https://agent-toolbelt-production.up.railway.app) — a suite of focused API tools for AI agents and developers.
+
+**Typed client + LangChain tool wrappers** for schema generation, text extraction, token counting, CSV conversion, Markdown conversion, URL metadata, regex building, cron expressions, address normalization, and color palette generation.
+
+## Install
+
+```bash
+npm install agent-toolbelt
+```
+
+## Get an API key
+
+```bash
+curl -X POST https://agent-toolbelt-production.up.railway.app/api/clients/register \
+  -H "Content-Type: application/json" \
+  -d '{"email": "you@example.com"}'
+```
+
+---
+
+## Typed Client
+
+```ts
+import { AgentToolbelt } from "agent-toolbelt";
+
+const client = new AgentToolbelt({ apiKey: process.env.AGENT_TOOLBELT_KEY! });
+```
+
+### Text Extractor
+
+Pull structured data out of raw text — no regex required.
+
+```ts
+const result = await client.textExtractor({
+  text: "Contact Sarah at sarah@acme.com or (555) 867-5309. Budget: $12,500.",
+  extractors: ["emails", "phone_numbers", "currencies"],
+});
+// result.extracted.emails       → ["sarah@acme.com"]
+// result.extracted.phone_numbers → ["+15558675309"]
+// result.extracted.currencies   → ["$12,500"]
+```
+
+### Token Counter
+
+Never get surprised by context window costs again.
+
+```ts
+const result = await client.tokenCounter({
+  text: longDocument,
+  models: ["gpt-4o", "claude-3-5-sonnet", "gpt-3.5-turbo"],
+});
+// result.results["gpt-4o"].tokens            → 1842
+// result.results["gpt-4o"].estimatedCost.input → 0.0000092 (USD)
+```
+
+### Schema Generator
+
+Describe your data in English, get back a schema.
+
+```ts
+const result = await client.schemaGenerator({
+  description: "a SaaS user with name, email, plan tier, and usage limits",
+  format: "typescript",
+});
+// result.schema → full TypeScript interface
+```
+
+### CSV to JSON
+
+Drop in CSV, get back typed JSON.
+
+```ts
+const result = await client.csvToJson({
+  csv: rawCsvString,
+  typeCast: true,   // "true" → true, "42" → 42, "" → null
+});
+// result.rows → [{ name: "Alice", age: 30, active: true }, ...]
+// result.columnTypes → { name: "string", age: "number", active: "boolean" }
+```
+
+### Markdown Converter
+
+Clean up HTML for LLM consumption.
+
+```ts
+const result = await client.markdownConverter({
+  content: scrapedHtml,
+  from: "html",
+  to: "markdown",
+});
+// result.output → clean Markdown without tags
+```
+
+### URL Metadata
+
+Enrich any link with context.
+
+```ts
+const result = await client.urlMetadata({ url: "https://example.com/article" });
+// result.metadata.title       → "Article Title"
+// result.metadata.description → "Meta description..."
+// result.metadata.og          → { image: "...", type: "article" }
+```
+
+### Other tools
+
+```ts
+// Natural language → cron expression
+await client.cronBuilder({ description: "every weekday at 9am", timezone: "America/New_York" });
+
+// Natural language → regex with code snippets
+await client.regexBuilder({ description: "US phone numbers", testStrings: ["555-867-5309"] });
+
+// Normalize messy US addresses to USPS format
+await client.addressNormalizer({ address: "123 main st apt 4b, springfield, il 62701" });
+
+// Generate color palettes from descriptions or hex colors
+await client.colorPalette({ description: "calm fintech blue", count: 5 });
+```
+
+---
+
+## LangChain Integration
+
+Use Agent Toolbelt tools directly in LangChain agents and chains.
+
+```ts
+import { AgentToolbelt } from "agent-toolbelt";
+import { createLangChainTools } from "agent-toolbelt/langchain";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { ChatOpenAI } from "@langchain/openai";
+
+const client = new AgentToolbelt({ apiKey: process.env.AGENT_TOOLBELT_KEY! });
+const tools = createLangChainTools(client);
+
+const agent = createReactAgent({
+  llm: new ChatOpenAI({ model: "gpt-4o" }),
+  tools,
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "Extract all emails and phone numbers from this text: ..." }],
+});
+```
+
+### Available LangChain tools
+
+| Tool name | Description |
+|---|---|
+| `extract_from_text` | Extract emails, URLs, phones, dates, currencies, addresses, names from text |
+| `count_tokens` | Count tokens and estimate cost across LLM models |
+| `generate_schema` | Generate JSON Schema / TypeScript / Zod from a description |
+| `csv_to_json` | Convert CSV to typed JSON with auto type casting |
+| `convert_markdown` | Convert HTML ↔ Markdown |
+| `fetch_url_metadata` | Get title, description, OG tags, favicon from a URL |
+| `build_regex` | Build and test regex patterns from natural language |
+| `build_cron` | Convert schedule descriptions to cron expressions |
+| `normalize_address` | Normalize US addresses to USPS format |
+| `generate_color_palette` | Generate color palettes with WCAG scores and CSS variables |
+
+---
+
+## All tools
+
+| Tool | Pricing |
+|---|---|
+| `schema-generator` | $0.001 / call |
+| `text-extractor` | $0.0005 / call |
+| `token-counter` | $0.0001 / call |
+| `csv-to-json` | $0.0005 / call |
+| `markdown-converter` | $0.0005 / call |
+| `url-metadata` | $0.001 / call |
+| `regex-builder` | $0.0005 / call |
+| `cron-builder` | $0.0005 / call |
+| `address-normalizer` | $0.0005 / call |
+| `color-palette` | $0.0005 / call |
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,201 @@
+interface AgentToolbeltOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface SchemaGeneratorResult {
+    schema: object | string;
+    format: "json_schema" | "zod" | "typescript";
+}
+interface TextExtractorResult {
+    extracted: Record<string, string[]>;
+    summary: {
+        totalItemsFound: number;
+        byType: Record<string, number>;
+    };
+}
+interface TokenCountResult {
+    characterCount: number;
+    wordCount: number;
+    results: Record<string, {
+        tokens: number;
+        encoding: string;
+        approximate: boolean;
+        estimatedCost?: {
+            input: number;
+            output: number;
+            currency: string;
+        };
+    }>;
+    supportedModels: string[];
+}
+interface CsvToJsonResult {
+    success: boolean;
+    rows: Record<string, unknown>[];
+    headers: string[];
+    rowCount: number;
+    totalRows: number;
+    columnCount: number;
+    columnTypes: Record<string, string>;
+    detectedDelimiter?: string;
+    truncated?: boolean;
+}
+interface MarkdownConverterResult {
+    output: string;
+    from: string;
+    to: string;
+    inputLength: number;
+    outputLength: number;
+}
+interface UrlMetadataResult {
+    url: string;
+    finalUrl: string;
+    statusCode: number | null;
+    error?: string;
+    metadata: {
+        title: string | null;
+        description: string | null;
+        favicon: string | null;
+        canonical: string | null;
+        author: string | null;
+        themeColor: string | null;
+        publishedTime: string | null;
+        modifiedTime: string | null;
+        og: Record<string, string>;
+        twitter: Record<string, string>;
+    } | null;
+}
+interface RegexBuilderResult {
+    pattern: string;
+    flags: string;
+    regexLiteral: string;
+    description: string;
+    category: string;
+    codeSnippets: {
+        javascript: string;
+        python: string;
+        typescript: string;
+    };
+    testResults?: Array<{
+        input: string;
+        matched: boolean;
+        matches: string[];
+    }>;
+}
+interface CronBuilderResult {
+    expression: string;
+    humanReadable: string;
+    timezone: string;
+    fields: Record<string, string>;
+    nextRuns: string[];
+    warnings: string[];
+}
+interface AddressNormalizerResult {
+    original: string;
+    normalized: string;
+    confidence: "high" | "medium" | "low";
+    components?: {
+        streetNumber?: string;
+        preDirectional?: string;
+        streetName?: string;
+        streetType?: string;
+        postDirectional?: string;
+        secondaryUnit?: string;
+        secondaryNumber?: string;
+        city?: string;
+        state?: string;
+        zip?: string;
+        zip4?: string;
+    };
+}
+interface ColorPaletteResult {
+    paletteName: string;
+    paletteLabel: string;
+    colors: Array<{
+        index: number;
+        name: string;
+        hex: string;
+        rgb?: string;
+        hsl?: string;
+        wcag: {
+            contrastOnWhite: number;
+            contrastOnBlack: number;
+            gradeOnWhite: string;
+            gradeOnBlack: string;
+        };
+    }>;
+    css: string;
+    swatches: string;
+}
+declare class AgentToolbelt {
+    private apiKey;
+    private baseUrl;
+    constructor({ apiKey, baseUrl }: AgentToolbeltOptions);
+    private call;
+    /** Generate JSON Schema, TypeScript, or Zod from a plain-English description */
+    schemaGenerator(input: {
+        description: string;
+        format?: "json_schema" | "zod" | "typescript";
+        strict?: boolean;
+    }): Promise<SchemaGeneratorResult>;
+    /** Extract emails, URLs, phone numbers, dates, currencies, addresses, or names from text */
+    textExtractor(input: {
+        text: string;
+        extractors: Array<"emails" | "urls" | "phone_numbers" | "dates" | "currencies" | "addresses" | "names" | "json_blocks">;
+        deduplicate?: boolean;
+    }): Promise<TextExtractorResult>;
+    /** Count tokens across multiple LLM models with cost estimates */
+    tokenCounter(input: {
+        text: string;
+        models?: string[];
+    }): Promise<TokenCountResult>;
+    /** Convert CSV to typed JSON with auto-delimiter detection and type casting */
+    csvToJson(input: {
+        csv: string;
+        delimiter?: "auto" | "," | ";" | "\t" | "|";
+        hasHeader?: boolean;
+        typeCast?: boolean;
+        limit?: number;
+        skipEmptyRows?: boolean;
+    }): Promise<CsvToJsonResult>;
+    /** Convert HTML to Markdown or Markdown to HTML */
+    markdownConverter(input: {
+        content: string;
+        from: "html" | "markdown";
+        to: "html" | "markdown";
+        options?: {
+            headingStyle?: "atx" | "setext";
+            bulletListMarker?: "-" | "*" | "+";
+            codeBlockStyle?: "fenced" | "indented";
+        };
+    }): Promise<MarkdownConverterResult>;
+    /** Fetch a URL and extract title, description, OG tags, favicon, and more */
+    urlMetadata(input: {
+        url: string;
+        timeout?: number;
+    }): Promise<UrlMetadataResult>;
+    /** Build and test regular expressions from natural language */
+    regexBuilder(input: {
+        description: string;
+        testStrings?: string[];
+        flags?: string;
+    }): Promise<RegexBuilderResult>;
+    /** Convert a natural language schedule to a cron expression */
+    cronBuilder(input: {
+        description: string;
+        timezone?: string;
+    }): Promise<CronBuilderResult>;
+    /** Normalize a US address to USPS format with component parsing */
+    addressNormalizer(input: {
+        address: string;
+        includeComponents?: boolean;
+    }): Promise<AddressNormalizerResult>;
+    /** Generate a color palette from a description or hex color */
+    colorPalette(input: {
+        description: string;
+        count?: number;
+        format?: "hex" | "rgb" | "hsl" | "all";
+        includeShades?: boolean;
+    }): Promise<ColorPaletteResult>;
+}
+
+export { type AddressNormalizerResult, AgentToolbelt, type AgentToolbeltOptions, type ColorPaletteResult, type CronBuilderResult, type CsvToJsonResult, type MarkdownConverterResult, type RegexBuilderResult, type SchemaGeneratorResult, type TextExtractorResult, type TokenCountResult, type UrlMetadataResult };

package/dist/index.d.ts

@@ -0,0 +1,201 @@
+interface AgentToolbeltOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface SchemaGeneratorResult {
+    schema: object | string;
+    format: "json_schema" | "zod" | "typescript";
+}
+interface TextExtractorResult {
+    extracted: Record<string, string[]>;
+    summary: {
+        totalItemsFound: number;
+        byType: Record<string, number>;
+    };
+}
+interface TokenCountResult {
+    characterCount: number;
+    wordCount: number;
+    results: Record<string, {
+        tokens: number;
+        encoding: string;
+        approximate: boolean;
+        estimatedCost?: {
+            input: number;
+            output: number;
+            currency: string;
+        };
+    }>;
+    supportedModels: string[];
+}
+interface CsvToJsonResult {
+    success: boolean;
+    rows: Record<string, unknown>[];
+    headers: string[];
+    rowCount: number;
+    totalRows: number;
+    columnCount: number;
+    columnTypes: Record<string, string>;
+    detectedDelimiter?: string;
+    truncated?: boolean;
+}
+interface MarkdownConverterResult {
+    output: string;
+    from: string;
+    to: string;
+    inputLength: number;
+    outputLength: number;
+}
+interface UrlMetadataResult {
+    url: string;
+    finalUrl: string;
+    statusCode: number | null;
+    error?: string;
+    metadata: {
+        title: string | null;
+        description: string | null;
+        favicon: string | null;
+        canonical: string | null;
+        author: string | null;
+        themeColor: string | null;
+        publishedTime: string | null;
+        modifiedTime: string | null;
+        og: Record<string, string>;
+        twitter: Record<string, string>;
+    } | null;
+}
+interface RegexBuilderResult {
+    pattern: string;
+    flags: string;
+    regexLiteral: string;
+    description: string;
+    category: string;
+    codeSnippets: {
+        javascript: string;
+        python: string;
+        typescript: string;
+    };
+    testResults?: Array<{
+        input: string;
+        matched: boolean;
+        matches: string[];
+    }>;
+}
+interface CronBuilderResult {
+    expression: string;
+    humanReadable: string;
+    timezone: string;
+    fields: Record<string, string>;
+    nextRuns: string[];
+    warnings: string[];
+}
+interface AddressNormalizerResult {
+    original: string;
+    normalized: string;
+    confidence: "high" | "medium" | "low";
+    components?: {
+        streetNumber?: string;
+        preDirectional?: string;
+        streetName?: string;
+        streetType?: string;
+        postDirectional?: string;
+        secondaryUnit?: string;
+        secondaryNumber?: string;
+        city?: string;
+        state?: string;
+        zip?: string;
+        zip4?: string;
+    };
+}
+interface ColorPaletteResult {
+    paletteName: string;
+    paletteLabel: string;
+    colors: Array<{
+        index: number;
+        name: string;
+        hex: string;
+        rgb?: string;
+        hsl?: string;
+        wcag: {
+            contrastOnWhite: number;
+            contrastOnBlack: number;
+            gradeOnWhite: string;
+            gradeOnBlack: string;
+        };
+    }>;
+    css: string;
+    swatches: string;
+}
+declare class AgentToolbelt {
+    private apiKey;
+    private baseUrl;
+    constructor({ apiKey, baseUrl }: AgentToolbeltOptions);
+    private call;
+    /** Generate JSON Schema, TypeScript, or Zod from a plain-English description */
+    schemaGenerator(input: {
+        description: string;
+        format?: "json_schema" | "zod" | "typescript";
+        strict?: boolean;
+    }): Promise<SchemaGeneratorResult>;
+    /** Extract emails, URLs, phone numbers, dates, currencies, addresses, or names from text */
+    textExtractor(input: {
+        text: string;
+        extractors: Array<"emails" | "urls" | "phone_numbers" | "dates" | "currencies" | "addresses" | "names" | "json_blocks">;
+        deduplicate?: boolean;
+    }): Promise<TextExtractorResult>;
+    /** Count tokens across multiple LLM models with cost estimates */
+    tokenCounter(input: {
+        text: string;
+        models?: string[];
+    }): Promise<TokenCountResult>;
+    /** Convert CSV to typed JSON with auto-delimiter detection and type casting */
+    csvToJson(input: {
+        csv: string;
+        delimiter?: "auto" | "," | ";" | "\t" | "|";
+        hasHeader?: boolean;
+        typeCast?: boolean;
+        limit?: number;
+        skipEmptyRows?: boolean;
+    }): Promise<CsvToJsonResult>;
+    /** Convert HTML to Markdown or Markdown to HTML */
+    markdownConverter(input: {
+        content: string;
+        from: "html" | "markdown";
+        to: "html" | "markdown";
+        options?: {
+            headingStyle?: "atx" | "setext";
+            bulletListMarker?: "-" | "*" | "+";
+            codeBlockStyle?: "fenced" | "indented";
+        };
+    }): Promise<MarkdownConverterResult>;
+    /** Fetch a URL and extract title, description, OG tags, favicon, and more */
+    urlMetadata(input: {
+        url: string;
+        timeout?: number;
+    }): Promise<UrlMetadataResult>;
+    /** Build and test regular expressions from natural language */
+    regexBuilder(input: {
+        description: string;
+        testStrings?: string[];
+        flags?: string;
+    }): Promise<RegexBuilderResult>;
+    /** Convert a natural language schedule to a cron expression */
+    cronBuilder(input: {
+        description: string;
+        timezone?: string;
+    }): Promise<CronBuilderResult>;
+    /** Normalize a US address to USPS format with component parsing */
+    addressNormalizer(input: {
+        address: string;
+        includeComponents?: boolean;
+    }): Promise<AddressNormalizerResult>;
+    /** Generate a color palette from a description or hex color */
+    colorPalette(input: {
+        description: string;
+        count?: number;
+        format?: "hex" | "rgb" | "hsl" | "all";
+        includeShades?: boolean;
+    }): Promise<ColorPaletteResult>;
+}
+
+export { type AddressNormalizerResult, AgentToolbelt, type AgentToolbeltOptions, type ColorPaletteResult, type CronBuilderResult, type CsvToJsonResult, type MarkdownConverterResult, type RegexBuilderResult, type SchemaGeneratorResult, type TextExtractorResult, type TokenCountResult, type UrlMetadataResult };

package/dist/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentToolbelt: () => AgentToolbelt
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://agent-toolbelt-production.up.railway.app";
+var AgentToolbelt = class {
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL }) {
+    if (!apiKey) throw new Error("AgentToolbelt: apiKey is required");
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async call(tool, input) {
+    const res = await fetch(`${this.baseUrl}/api/tools/${tool}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(input)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(
+        `AgentToolbelt API error (${res.status}): ${err.message || err.error || res.statusText}`
+      );
+    }
+    const data = await res.json();
+    return data.result;
+  }
+  /** Generate JSON Schema, TypeScript, or Zod from a plain-English description */
+  schemaGenerator(input) {
+    return this.call("schema-generator", input);
+  }
+  /** Extract emails, URLs, phone numbers, dates, currencies, addresses, or names from text */
+  textExtractor(input) {
+    return this.call("text-extractor", input);
+  }
+  /** Count tokens across multiple LLM models with cost estimates */
+  tokenCounter(input) {
+    return this.call("token-counter", input);
+  }
+  /** Convert CSV to typed JSON with auto-delimiter detection and type casting */
+  csvToJson(input) {
+    return this.call("csv-to-json", input);
+  }
+  /** Convert HTML to Markdown or Markdown to HTML */
+  markdownConverter(input) {
+    return this.call("markdown-converter", input);
+  }
+  /** Fetch a URL and extract title, description, OG tags, favicon, and more */
+  urlMetadata(input) {
+    return this.call("url-metadata", input);
+  }
+  /** Build and test regular expressions from natural language */
+  regexBuilder(input) {
+    return this.call("regex-builder", input);
+  }
+  /** Convert a natural language schedule to a cron expression */
+  cronBuilder(input) {
+    return this.call("cron-builder", input);
+  }
+  /** Normalize a US address to USPS format with component parsing */
+  addressNormalizer(input) {
+    return this.call("address-normalizer", input);
+  }
+  /** Generate a color palette from a description or hex color */
+  colorPalette(input) {
+    return this.call("color-palette", input);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentToolbelt
+});

package/dist/index.mjs

@@ -0,0 +1,70 @@
+// src/client.ts
+var DEFAULT_BASE_URL = "https://agent-toolbelt-production.up.railway.app";
+var AgentToolbelt = class {
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL }) {
+    if (!apiKey) throw new Error("AgentToolbelt: apiKey is required");
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async call(tool, input) {
+    const res = await fetch(`${this.baseUrl}/api/tools/${tool}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(input)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(
+        `AgentToolbelt API error (${res.status}): ${err.message || err.error || res.statusText}`
+      );
+    }
+    const data = await res.json();
+    return data.result;
+  }
+  /** Generate JSON Schema, TypeScript, or Zod from a plain-English description */
+  schemaGenerator(input) {
+    return this.call("schema-generator", input);
+  }
+  /** Extract emails, URLs, phone numbers, dates, currencies, addresses, or names from text */
+  textExtractor(input) {
+    return this.call("text-extractor", input);
+  }
+  /** Count tokens across multiple LLM models with cost estimates */
+  tokenCounter(input) {
+    return this.call("token-counter", input);
+  }
+  /** Convert CSV to typed JSON with auto-delimiter detection and type casting */
+  csvToJson(input) {
+    return this.call("csv-to-json", input);
+  }
+  /** Convert HTML to Markdown or Markdown to HTML */
+  markdownConverter(input) {
+    return this.call("markdown-converter", input);
+  }
+  /** Fetch a URL and extract title, description, OG tags, favicon, and more */
+  urlMetadata(input) {
+    return this.call("url-metadata", input);
+  }
+  /** Build and test regular expressions from natural language */
+  regexBuilder(input) {
+    return this.call("regex-builder", input);
+  }
+  /** Convert a natural language schedule to a cron expression */
+  cronBuilder(input) {
+    return this.call("cron-builder", input);
+  }
+  /** Normalize a US address to USPS format with component parsing */
+  addressNormalizer(input) {
+    return this.call("address-normalizer", input);
+  }
+  /** Generate a color palette from a description or hex color */
+  colorPalette(input) {
+    return this.call("color-palette", input);
+  }
+};
+export {
+  AgentToolbelt
+};

package/dist/langchain.d.mts

@@ -0,0 +1,22 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { AgentToolbelt } from './index.mjs';
+
+/**
+ * Create a set of LangChain DynamicStructuredTools from an AgentToolbelt client.
+ *
+ * @example
+ * ```ts
+ * import { AgentToolbelt } from "agent-toolbelt";
+ * import { createLangChainTools } from "agent-toolbelt/langchain";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * const client = new AgentToolbelt({ apiKey: process.env.AGENT_TOOLBELT_KEY! });
+ * const tools = createLangChainTools(client);
+ *
+ * const agent = createReactAgent({ llm: new ChatOpenAI({ model: "gpt-4o" }), tools });
+ * ```
+ */
+declare function createLangChainTools(client: AgentToolbelt): DynamicStructuredTool[];
+
+export { createLangChainTools };

package/dist/langchain.d.ts

@@ -0,0 +1,22 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { AgentToolbelt } from './index.js';
+
+/**
+ * Create a set of LangChain DynamicStructuredTools from an AgentToolbelt client.
+ *
+ * @example
+ * ```ts
+ * import { AgentToolbelt } from "agent-toolbelt";
+ * import { createLangChainTools } from "agent-toolbelt/langchain";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * const client = new AgentToolbelt({ apiKey: process.env.AGENT_TOOLBELT_KEY! });
+ * const tools = createLangChainTools(client);
+ *
+ * const agent = createReactAgent({ llm: new ChatOpenAI({ model: "gpt-4o" }), tools });
+ * ```
+ */
+declare function createLangChainTools(client: AgentToolbelt): DynamicStructuredTool[];
+
+export { createLangChainTools };

package/dist/langchain.js

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  createLangChainTools: () => createLangChainTools
+});
+module.exports = __toCommonJS(langchain_exports);
+var import_tools = require("@langchain/core/tools");
+var import_zod = require("zod");
+function createLangChainTools(client) {
+  return [
+    // ---- Text Extractor ----
+    new import_tools.DynamicStructuredTool({
+      name: "extract_from_text",
+      description: "Extract structured data from raw, unstructured text. Use this when you need to pull out specific types of data from a document, email, web page, or any text \u2014 such as all email addresses, phone numbers, dates, URLs, currencies, addresses, or names. Returns a structured JSON object with arrays of matched items per type. Example use cases: parsing contact info from a scraped page, finding all dates in a contract, extracting prices from a product description.",
+      schema: import_zod.z.object({
+        text: import_zod.z.string().describe("The raw text to extract data from"),
+        extractors: import_zod.z.array(import_zod.z.enum(["emails", "urls", "phone_numbers", "dates", "currencies", "addresses", "names", "json_blocks"])).describe("Which types of data to extract. Pick all that apply."),
+        deduplicate: import_zod.z.boolean().default(true).describe("Remove duplicate results")
+      }),
+      func: async ({ text, extractors, deduplicate }) => {
+        const result = await client.textExtractor({ text, extractors, deduplicate });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Token Counter ----
+    new import_tools.DynamicStructuredTool({
+      name: "count_tokens",
+      description: "Count how many tokens a piece of text will consume in different LLM models, and estimate the API cost. Use this before sending large text to an LLM to check if it fits in the context window, to compare costs across models, or to decide whether to chunk or summarize content. Supports GPT-4o, GPT-4, GPT-3.5-turbo, Claude 3.5 Sonnet, Claude 3 Opus, and 10+ other models. Returns exact token counts for OpenAI models and close approximations for Claude.",
+      schema: import_zod.z.object({
+        text: import_zod.z.string().describe("The text to count tokens for"),
+        models: import_zod.z.array(import_zod.z.string()).default(["gpt-4o", "claude-3-5-sonnet"]).describe("Models to count tokens for. Defaults to gpt-4o and claude-3-5-sonnet.")
+      }),
+      func: async ({ text, models }) => {
+        const result = await client.tokenCounter({ text, models });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Schema Generator ----
+    new import_tools.DynamicStructuredTool({
+      name: "generate_schema",
+      description: "Generate a JSON Schema, TypeScript interface, or Zod validation schema from a plain English description of a data structure. Use this when you need to define a data model, validate incoming data, or create type definitions without writing them by hand. Example: 'a user profile with name, email, and subscription tier' \u2192 full JSON Schema with required fields and types. Ideal for agents that dynamically create or validate data structures based on user requirements.",
+      schema: import_zod.z.object({
+        description: import_zod.z.string().describe("Plain English description of the data structure. Be specific about field names and types."),
+        format: import_zod.z.enum(["json_schema", "typescript", "zod"]).default("json_schema").describe("Output format: json_schema (standard), typescript (TS interface), or zod (Zod validator)"),
+        strict: import_zod.z.boolean().default(true).describe("If true, all fields are required")
+      }),
+      func: async ({ description, format, strict }) => {
+        const result = await client.schemaGenerator({ description, format, strict });
+        return typeof result.schema === "string" ? result.schema : JSON.stringify(result.schema, null, 2);
+      }
+    }),
+    // ---- CSV to JSON ----
+    new import_tools.DynamicStructuredTool({
+      name: "csv_to_json",
+      description: "Convert CSV data into typed JSON. Use this when you have spreadsheet data, database exports, or any CSV-formatted content that needs to be processed as structured JSON. Automatically detects delimiters (comma, tab, semicolon, pipe), converts numbers to actual numbers, 'true'/'false' to booleans, empty cells to null, and infers column types. Returns an array of row objects with column names as keys.",
+      schema: import_zod.z.object({
+        csv: import_zod.z.string().describe("The CSV content to convert"),
+        delimiter: import_zod.z.enum(["auto", ",", ";", "	", "|"]).default("auto").describe("Column delimiter (auto-detects by default)"),
+        hasHeader: import_zod.z.boolean().default(true).describe("Whether the first row contains column names"),
+        typeCast: import_zod.z.boolean().default(true).describe("Auto-convert values to numbers, booleans, and nulls"),
+        limit: import_zod.z.number().optional().describe("Max rows to return (useful for large files)")
+      }),
+      func: async ({ csv, delimiter, hasHeader, typeCast, limit }) => {
+        const result = await client.csvToJson({ csv, delimiter, hasHeader, typeCast, limit, skipEmptyRows: true });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Markdown Converter ----
+    new import_tools.DynamicStructuredTool({
+      name: "convert_markdown",
+      description: "Convert HTML to clean Markdown, or Markdown to HTML. Use HTML\u2192Markdown when you've fetched a web page and need clean, readable text for an LLM \u2014 stripping HTML tags, preserving structure (headings, lists, code blocks, links, tables). Use Markdown\u2192HTML when you need to render content in a web context. Handles complex HTML including nested lists, code blocks with language hints, tables, and inline formatting.",
+      schema: import_zod.z.object({
+        content: import_zod.z.string().describe("The content to convert"),
+        from: import_zod.z.enum(["html", "markdown"]).describe("Input format"),
+        to: import_zod.z.enum(["html", "markdown"]).describe("Output format")
+      }),
+      func: async ({ content, from, to }) => {
+        const result = await client.markdownConverter({ content, from, to });
+        return result.output;
+      }
+    }),
+    // ---- URL Metadata ----
+    new import_tools.DynamicStructuredTool({
+      name: "fetch_url_metadata",
+      description: "Fetch a URL and extract its metadata: page title, meta description, Open Graph tags (og:image, og:type, og:site_name), Twitter card tags, favicon URL, canonical URL, author, and publish/modified dates. Use this to enrich a URL with context before presenting it to a user, to get the main image or description for a link preview, or to quickly understand what a page is about without reading the full content.",
+      schema: import_zod.z.object({
+        url: import_zod.z.string().url().describe("The URL to fetch metadata from"),
+        timeout: import_zod.z.number().default(8e3).describe("Request timeout in ms (default 8000)")
+      }),
+      func: async ({ url, timeout }) => {
+        const result = await client.urlMetadata({ url, timeout });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Regex Builder ----
+    new import_tools.DynamicStructuredTool({
+      name: "build_regex",
+      description: "Build and test a regular expression from a natural language description. Use this when you need a regex pattern for validation, parsing, or data extraction \u2014 without needing to write or debug regex syntax yourself. Supports 20+ common patterns: email, URL, phone number, date, IP address, hex color, UUID, slug, JWT, credit card, SSN, and more. Optionally test the pattern against provided strings. Returns ready-to-use code in JavaScript, Python, and TypeScript.",
+      schema: import_zod.z.object({
+        description: import_zod.z.string().describe("What the regex should match (e.g. 'valid email addresses', 'US phone numbers with area code')"),
+        testStrings: import_zod.z.array(import_zod.z.string()).optional().describe("Optional strings to test the regex against"),
+        flags: import_zod.z.string().default("g").describe("Regex flags (default: 'g' for global)")
+      }),
+      func: async ({ description, testStrings, flags }) => {
+        const result = await client.regexBuilder({ description, testStrings, flags });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Cron Builder ----
+    new import_tools.DynamicStructuredTool({
+      name: "build_cron",
+      description: "Convert a natural language schedule description into a cron expression. Use this when setting up scheduled jobs, tasks, or automation workflows. Examples: 'every weekday at 9am EST', 'first Monday of every month at noon', 'every 15 minutes', 'twice a day at 8am and 6pm'. Returns the cron expression, a human-readable confirmation of the schedule, and the next 5 run times.",
+      schema: import_zod.z.object({
+        description: import_zod.z.string().describe("Natural language schedule description"),
+        timezone: import_zod.z.string().default("UTC").describe("Timezone (e.g. 'America/New_York', 'Europe/London')")
+      }),
+      func: async ({ description, timezone }) => {
+        const result = await client.cronBuilder({ description, timezone });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Address Normalizer ----
+    new import_tools.DynamicStructuredTool({
+      name: "normalize_address",
+      description: "Normalize a US mailing address to USPS standard format. Use this when cleaning address data for mailing, geocoding, deduplication, or database storage. Expands abbreviations (st\u2192ST, ave\u2192AVE, apt\u2192APT), standardizes directionals (north\u2192N), converts state names to abbreviations (California\u2192CA), and parses the address into components. Returns a confidence score (high/medium/low) indicating parse quality.",
+      schema: import_zod.z.object({
+        address: import_zod.z.string().describe("The address to normalize (e.g. '123 main st apt 4b, springfield, il 62701')"),
+        includeComponents: import_zod.z.boolean().default(true).describe("Include parsed components (street number, city, state, ZIP, etc.)")
+      }),
+      func: async ({ address, includeComponents }) => {
+        const result = await client.addressNormalizer({ address, includeComponents });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Color Palette ----
+    new import_tools.DynamicStructuredTool({
+      name: "generate_color_palette",
+      description: "Generate a color palette from a description, mood, industry, or hex color seed. Use this for branding, UI design, or any task requiring a cohesive set of colors. Accepts moods ('calm', 'energetic', 'luxurious'), industries ('fintech', 'healthcare', 'fashion'), nature themes ('sunset', 'ocean', 'forest'), or a specific hex color to build around. Returns hex/RGB/HSL values, WCAG accessibility contrast scores, and ready-to-use CSS custom properties.",
+      schema: import_zod.z.object({
+        description: import_zod.z.string().describe("Description of desired palette (e.g. 'professional fintech blue', 'warm sunset', '#3B82F6')"),
+        count: import_zod.z.number().int().min(2).max(10).default(5).describe("Number of colors (2-10)"),
+        format: import_zod.z.enum(["hex", "rgb", "hsl", "all"]).default("all").describe("Color format in output")
+      }),
+      func: async ({ description, count, format }) => {
+        const result = await client.colorPalette({ description, count, format });
+        return JSON.stringify(result);
+      }
+    })
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLangChainTools
+});

package/dist/langchain.mjs

@@ -0,0 +1,148 @@
+// src/langchain.ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+function createLangChainTools(client) {
+  return [
+    // ---- Text Extractor ----
+    new DynamicStructuredTool({
+      name: "extract_from_text",
+      description: "Extract structured data from raw, unstructured text. Use this when you need to pull out specific types of data from a document, email, web page, or any text \u2014 such as all email addresses, phone numbers, dates, URLs, currencies, addresses, or names. Returns a structured JSON object with arrays of matched items per type. Example use cases: parsing contact info from a scraped page, finding all dates in a contract, extracting prices from a product description.",
+      schema: z.object({
+        text: z.string().describe("The raw text to extract data from"),
+        extractors: z.array(z.enum(["emails", "urls", "phone_numbers", "dates", "currencies", "addresses", "names", "json_blocks"])).describe("Which types of data to extract. Pick all that apply."),
+        deduplicate: z.boolean().default(true).describe("Remove duplicate results")
+      }),
+      func: async ({ text, extractors, deduplicate }) => {
+        const result = await client.textExtractor({ text, extractors, deduplicate });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Token Counter ----
+    new DynamicStructuredTool({
+      name: "count_tokens",
+      description: "Count how many tokens a piece of text will consume in different LLM models, and estimate the API cost. Use this before sending large text to an LLM to check if it fits in the context window, to compare costs across models, or to decide whether to chunk or summarize content. Supports GPT-4o, GPT-4, GPT-3.5-turbo, Claude 3.5 Sonnet, Claude 3 Opus, and 10+ other models. Returns exact token counts for OpenAI models and close approximations for Claude.",
+      schema: z.object({
+        text: z.string().describe("The text to count tokens for"),
+        models: z.array(z.string()).default(["gpt-4o", "claude-3-5-sonnet"]).describe("Models to count tokens for. Defaults to gpt-4o and claude-3-5-sonnet.")
+      }),
+      func: async ({ text, models }) => {
+        const result = await client.tokenCounter({ text, models });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Schema Generator ----
+    new DynamicStructuredTool({
+      name: "generate_schema",
+      description: "Generate a JSON Schema, TypeScript interface, or Zod validation schema from a plain English description of a data structure. Use this when you need to define a data model, validate incoming data, or create type definitions without writing them by hand. Example: 'a user profile with name, email, and subscription tier' \u2192 full JSON Schema with required fields and types. Ideal for agents that dynamically create or validate data structures based on user requirements.",
+      schema: z.object({
+        description: z.string().describe("Plain English description of the data structure. Be specific about field names and types."),
+        format: z.enum(["json_schema", "typescript", "zod"]).default("json_schema").describe("Output format: json_schema (standard), typescript (TS interface), or zod (Zod validator)"),
+        strict: z.boolean().default(true).describe("If true, all fields are required")
+      }),
+      func: async ({ description, format, strict }) => {
+        const result = await client.schemaGenerator({ description, format, strict });
+        return typeof result.schema === "string" ? result.schema : JSON.stringify(result.schema, null, 2);
+      }
+    }),
+    // ---- CSV to JSON ----
+    new DynamicStructuredTool({
+      name: "csv_to_json",
+      description: "Convert CSV data into typed JSON. Use this when you have spreadsheet data, database exports, or any CSV-formatted content that needs to be processed as structured JSON. Automatically detects delimiters (comma, tab, semicolon, pipe), converts numbers to actual numbers, 'true'/'false' to booleans, empty cells to null, and infers column types. Returns an array of row objects with column names as keys.",
+      schema: z.object({
+        csv: z.string().describe("The CSV content to convert"),
+        delimiter: z.enum(["auto", ",", ";", "	", "|"]).default("auto").describe("Column delimiter (auto-detects by default)"),
+        hasHeader: z.boolean().default(true).describe("Whether the first row contains column names"),
+        typeCast: z.boolean().default(true).describe("Auto-convert values to numbers, booleans, and nulls"),
+        limit: z.number().optional().describe("Max rows to return (useful for large files)")
+      }),
+      func: async ({ csv, delimiter, hasHeader, typeCast, limit }) => {
+        const result = await client.csvToJson({ csv, delimiter, hasHeader, typeCast, limit, skipEmptyRows: true });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Markdown Converter ----
+    new DynamicStructuredTool({
+      name: "convert_markdown",
+      description: "Convert HTML to clean Markdown, or Markdown to HTML. Use HTML\u2192Markdown when you've fetched a web page and need clean, readable text for an LLM \u2014 stripping HTML tags, preserving structure (headings, lists, code blocks, links, tables). Use Markdown\u2192HTML when you need to render content in a web context. Handles complex HTML including nested lists, code blocks with language hints, tables, and inline formatting.",
+      schema: z.object({
+        content: z.string().describe("The content to convert"),
+        from: z.enum(["html", "markdown"]).describe("Input format"),
+        to: z.enum(["html", "markdown"]).describe("Output format")
+      }),
+      func: async ({ content, from, to }) => {
+        const result = await client.markdownConverter({ content, from, to });
+        return result.output;
+      }
+    }),
+    // ---- URL Metadata ----
+    new DynamicStructuredTool({
+      name: "fetch_url_metadata",
+      description: "Fetch a URL and extract its metadata: page title, meta description, Open Graph tags (og:image, og:type, og:site_name), Twitter card tags, favicon URL, canonical URL, author, and publish/modified dates. Use this to enrich a URL with context before presenting it to a user, to get the main image or description for a link preview, or to quickly understand what a page is about without reading the full content.",
+      schema: z.object({
+        url: z.string().url().describe("The URL to fetch metadata from"),
+        timeout: z.number().default(8e3).describe("Request timeout in ms (default 8000)")
+      }),
+      func: async ({ url, timeout }) => {
+        const result = await client.urlMetadata({ url, timeout });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Regex Builder ----
+    new DynamicStructuredTool({
+      name: "build_regex",
+      description: "Build and test a regular expression from a natural language description. Use this when you need a regex pattern for validation, parsing, or data extraction \u2014 without needing to write or debug regex syntax yourself. Supports 20+ common patterns: email, URL, phone number, date, IP address, hex color, UUID, slug, JWT, credit card, SSN, and more. Optionally test the pattern against provided strings. Returns ready-to-use code in JavaScript, Python, and TypeScript.",
+      schema: z.object({
+        description: z.string().describe("What the regex should match (e.g. 'valid email addresses', 'US phone numbers with area code')"),
+        testStrings: z.array(z.string()).optional().describe("Optional strings to test the regex against"),
+        flags: z.string().default("g").describe("Regex flags (default: 'g' for global)")
+      }),
+      func: async ({ description, testStrings, flags }) => {
+        const result = await client.regexBuilder({ description, testStrings, flags });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Cron Builder ----
+    new DynamicStructuredTool({
+      name: "build_cron",
+      description: "Convert a natural language schedule description into a cron expression. Use this when setting up scheduled jobs, tasks, or automation workflows. Examples: 'every weekday at 9am EST', 'first Monday of every month at noon', 'every 15 minutes', 'twice a day at 8am and 6pm'. Returns the cron expression, a human-readable confirmation of the schedule, and the next 5 run times.",
+      schema: z.object({
+        description: z.string().describe("Natural language schedule description"),
+        timezone: z.string().default("UTC").describe("Timezone (e.g. 'America/New_York', 'Europe/London')")
+      }),
+      func: async ({ description, timezone }) => {
+        const result = await client.cronBuilder({ description, timezone });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Address Normalizer ----
+    new DynamicStructuredTool({
+      name: "normalize_address",
+      description: "Normalize a US mailing address to USPS standard format. Use this when cleaning address data for mailing, geocoding, deduplication, or database storage. Expands abbreviations (st\u2192ST, ave\u2192AVE, apt\u2192APT), standardizes directionals (north\u2192N), converts state names to abbreviations (California\u2192CA), and parses the address into components. Returns a confidence score (high/medium/low) indicating parse quality.",
+      schema: z.object({
+        address: z.string().describe("The address to normalize (e.g. '123 main st apt 4b, springfield, il 62701')"),
+        includeComponents: z.boolean().default(true).describe("Include parsed components (street number, city, state, ZIP, etc.)")
+      }),
+      func: async ({ address, includeComponents }) => {
+        const result = await client.addressNormalizer({ address, includeComponents });
+        return JSON.stringify(result);
+      }
+    }),
+    // ---- Color Palette ----
+    new DynamicStructuredTool({
+      name: "generate_color_palette",
+      description: "Generate a color palette from a description, mood, industry, or hex color seed. Use this for branding, UI design, or any task requiring a cohesive set of colors. Accepts moods ('calm', 'energetic', 'luxurious'), industries ('fintech', 'healthcare', 'fashion'), nature themes ('sunset', 'ocean', 'forest'), or a specific hex color to build around. Returns hex/RGB/HSL values, WCAG accessibility contrast scores, and ready-to-use CSS custom properties.",
+      schema: z.object({
+        description: z.string().describe("Description of desired palette (e.g. 'professional fintech blue', 'warm sunset', '#3B82F6')"),
+        count: z.number().int().min(2).max(10).default(5).describe("Number of colors (2-10)"),
+        format: z.enum(["hex", "rgb", "hsl", "all"]).default("all").describe("Color format in output")
+      }),
+      func: async ({ description, count, format }) => {
+        const result = await client.colorPalette({ description, count, format });
+        return JSON.stringify(result);
+      }
+    })
+  ];
+}
+export {
+  createLangChainTools
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "agent-toolbelt",
+  "version": "0.1.0",
+  "description": "Official SDK for Agent Toolbelt — typed API client and LangChain tool wrappers for schema generation, text extraction, token counting, CSV conversion, and more.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./langchain": {
+      "types": "./dist/langchain.d.ts",
+      "import": "./dist/langchain.mjs",
+      "require": "./dist/langchain.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts src/langchain.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/langchain.ts --format cjs,esm --dts --watch"
+  },
+  "keywords": [
+    "langchain", "ai", "agent", "tools", "schema", "text-extraction",
+    "token-counter", "csv", "markdown", "llm", "openai", "claude"
+  ],
+  "author": "Agent Toolbelt",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marras0914/agent-toolbelt"
+  },
+  "homepage": "https://agent-toolbelt-production.up.railway.app",
+  "peerDependencies": {
+    "@langchain/core": ">=0.2.0",
+    "zod": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": { "optional": true }
+  },
+  "devDependencies": {
+    "@langchain/core": "^0.3.0",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "zod": "^3.22.0"
+  }
+}