@cogitator-ai/core 0.1.0

package/dist/tools/index.d.ts

@@ -0,0 +1,323 @@
+/**
+ * Built-in tools for Cogitator
+ */
+export { calculator } from './calculator';
+export { datetime } from './datetime';
+export { uuid } from './uuid';
+export { randomNumber, randomString } from './random';
+export { hash } from './hash';
+export { base64Encode, base64Decode } from './base64';
+export { sleep } from './sleep';
+export { jsonParse, jsonStringify } from './json';
+export { regexMatch, regexReplace } from './regex';
+export { fileRead, fileWrite, fileList, fileExists, fileDelete } from './filesystem';
+export { httpRequest } from './http';
+export { exec } from './exec';
+export declare const builtinTools: readonly [import("@cogitator-ai/types").Tool<{
+    expression: string;
+}, {
+    error: string;
+    expression: string;
+    result?: undefined;
+} | {
+    result: number;
+    expression: string;
+    error?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    timezone?: string | undefined;
+    format?: "date" | "iso" | "unix" | "readable" | "time" | undefined;
+}, {
+    error: string;
+    timezone: string;
+    datetime?: undefined;
+    format?: undefined;
+} | {
+    datetime: string;
+    timezone: string;
+    format: "date" | "iso" | "unix" | "readable" | "time";
+    error?: undefined;
+} | {
+    error: string;
+    timezone?: undefined;
+    datetime?: undefined;
+    format?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    count?: number | undefined;
+}, {
+    uuid: `${string}-${string}-${string}-${string}-${string}`;
+    uuids?: undefined;
+    count?: undefined;
+} | {
+    uuids: `${string}-${string}-${string}-${string}-${string}`[];
+    count: number;
+    uuid?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    integer?: boolean | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+}, {
+    error: string;
+    min: number;
+    max: number;
+    result?: undefined;
+    integer?: undefined;
+} | {
+    result: number;
+    min: number;
+    max: number;
+    integer: boolean;
+    error?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    length: number;
+    charset?: "numeric" | "alphanumeric" | "alpha" | "hex" | undefined;
+}, {
+    result: string;
+    length: number;
+    charset: "numeric" | "alphanumeric" | "alpha" | "hex";
+}>, import("@cogitator-ai/types").Tool<{
+    data: string;
+    algorithm?: "md5" | "sha1" | "sha256" | "sha512" | undefined;
+    encoding?: "hex" | "base64" | undefined;
+}, {
+    hash: string;
+    algorithm: "md5" | "sha1" | "sha256" | "sha512";
+    encoding: "hex" | "base64";
+    error?: undefined;
+} | {
+    error: string;
+    algorithm: "md5" | "sha1" | "sha256" | "sha512";
+    hash?: undefined;
+    encoding?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    data: string;
+    urlSafe?: boolean | undefined;
+}, {
+    result: string;
+    urlSafe: boolean;
+}>, import("@cogitator-ai/types").Tool<{
+    data: string;
+    urlSafe?: boolean | undefined;
+}, {
+    result: string;
+    urlSafe: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    result?: undefined;
+    urlSafe?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    ms: number;
+}, {
+    slept: number;
+    requested: number;
+}>, import("@cogitator-ai/types").Tool<{
+    json: string;
+}, {
+    result: unknown;
+    valid: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    valid: boolean;
+    result?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    pretty?: boolean | undefined;
+    data?: unknown;
+    indent?: number | undefined;
+}, {
+    result: string;
+    pretty: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    result?: undefined;
+    pretty?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    text: string;
+    pattern: string;
+    flags?: string | undefined;
+}, {
+    matches: {
+        match: string;
+        index: number;
+        groups?: Record<string, string>;
+    }[];
+    count: number;
+    pattern: string;
+    flags: string;
+    error?: undefined;
+} | {
+    error: string;
+    pattern: string;
+    matches?: undefined;
+    count?: undefined;
+    flags?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    text: string;
+    pattern: string;
+    replacement: string;
+    flags?: string | undefined;
+}, {
+    result: string;
+    replacements: number;
+    pattern: string;
+    flags: string;
+    error?: undefined;
+} | {
+    error: string;
+    pattern: string;
+    result?: undefined;
+    replacements?: undefined;
+    flags?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    path: string;
+    encoding?: "base64" | "utf-8" | undefined;
+}, {
+    content: string;
+    path: string;
+    encoding: "base64";
+    size: number;
+    error?: undefined;
+} | {
+    content: string;
+    path: string;
+    encoding: "utf-8";
+    size: number;
+    error?: undefined;
+} | {
+    error: string;
+    path: string;
+    content?: undefined;
+    encoding?: undefined;
+    size?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    path: string;
+    content: string;
+    encoding?: "base64" | "utf-8" | undefined;
+    createDirs?: boolean | undefined;
+}, {
+    success: boolean;
+    path: string;
+    size: number;
+    error?: undefined;
+} | {
+    error: string;
+    path: string;
+    success?: undefined;
+    size?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    path: string;
+    recursive?: boolean | undefined;
+    includeHidden?: boolean | undefined;
+}, {
+    entries: import("./filesystem").FileEntry[];
+    count: number;
+    path: string;
+    recursive: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    path: string;
+    entries?: undefined;
+    count?: undefined;
+    recursive?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    path: string;
+}, {
+    exists: boolean;
+    type: string;
+    size: number;
+    path: string;
+    error?: undefined;
+} | {
+    exists: boolean;
+    path: string;
+    type?: undefined;
+    size?: undefined;
+    error?: undefined;
+} | {
+    error: string;
+    path: string;
+    exists?: undefined;
+    type?: undefined;
+    size?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    path: string;
+    recursive?: boolean | undefined;
+}, {
+    success: boolean;
+    path: string;
+    type: string;
+    error?: undefined;
+} | {
+    error: string;
+    path: string;
+    success?: undefined;
+    type?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    url: string;
+    timeout?: number | undefined;
+    method?: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | undefined;
+    headers?: Record<string, string> | undefined;
+    body?: string | undefined;
+}, {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    truncated: boolean;
+    url: string;
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+    error?: undefined;
+} | {
+    error: string;
+    url: string;
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+    status?: undefined;
+    statusText?: undefined;
+    headers?: undefined;
+    body?: undefined;
+    truncated?: undefined;
+}>, import("@cogitator-ai/types").Tool<{
+    command: string;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    truncatedStdout: boolean;
+    truncatedStderr: boolean;
+    command: string;
+    error?: undefined;
+    timeout?: undefined;
+} | {
+    error: string;
+    command: string;
+    timeout: number;
+    stdout?: undefined;
+    stderr?: undefined;
+    exitCode?: undefined;
+    truncatedStdout?: undefined;
+    truncatedStderr?: undefined;
+} | {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    command: string;
+    truncatedStdout?: undefined;
+    truncatedStderr?: undefined;
+    error?: undefined;
+    timeout?: undefined;
+} | {
+    error: string;
+    command: string;
+    stdout?: undefined;
+    stderr?: undefined;
+    exitCode?: undefined;
+    truncatedStdout?: undefined;
+    truncatedStderr?: undefined;
+    timeout?: undefined;
+}>];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAErF,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAe9B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBf,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,50 @@
+/**
+ * Built-in tools for Cogitator
+ */
+export { calculator } from './calculator';
+export { datetime } from './datetime';
+export { uuid } from './uuid';
+export { randomNumber, randomString } from './random';
+export { hash } from './hash';
+export { base64Encode, base64Decode } from './base64';
+export { sleep } from './sleep';
+export { jsonParse, jsonStringify } from './json';
+export { regexMatch, regexReplace } from './regex';
+export { fileRead, fileWrite, fileList, fileExists, fileDelete } from './filesystem';
+export { httpRequest } from './http';
+export { exec } from './exec';
+import { calculator } from './calculator';
+import { datetime } from './datetime';
+import { uuid } from './uuid';
+import { randomNumber, randomString } from './random';
+import { hash } from './hash';
+import { base64Encode, base64Decode } from './base64';
+import { sleep } from './sleep';
+import { jsonParse, jsonStringify } from './json';
+import { regexMatch, regexReplace } from './regex';
+import { fileRead, fileWrite, fileList, fileExists, fileDelete } from './filesystem';
+import { httpRequest } from './http';
+import { exec } from './exec';
+export const builtinTools = [
+    calculator,
+    datetime,
+    uuid,
+    randomNumber,
+    randomString,
+    hash,
+    base64Encode,
+    base64Decode,
+    sleep,
+    jsonParse,
+    jsonStringify,
+    regexMatch,
+    regexReplace,
+    fileRead,
+    fileWrite,
+    fileList,
+    fileExists,
+    fileDelete,
+    httpRequest,
+    exec,
+];
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAErF,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,UAAU;IACV,QAAQ;IACR,IAAI;IACJ,YAAY;IACZ,YAAY;IACZ,IAAI;IACJ,YAAY;IACZ,YAAY;IACZ,KAAK;IACL,SAAS;IACT,aAAa;IACb,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,UAAU;IACV,UAAU;IACV,WAAW;IACX,IAAI;CACI,CAAC"}

package/dist/tools/json.d.ts

@@ -0,0 +1,28 @@
+/**
+ * JSON tools - parse and stringify JSON
+ */
+export declare const jsonParse: import("@cogitator-ai/types").Tool<{
+    json: string;
+}, {
+    result: unknown;
+    valid: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    valid: boolean;
+    result?: undefined;
+}>;
+export declare const jsonStringify: import("@cogitator-ai/types").Tool<{
+    pretty?: boolean | undefined;
+    data?: unknown;
+    indent?: number | undefined;
+}, {
+    result: string;
+    pretty: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    result?: undefined;
+    pretty?: undefined;
+}>;
+//# sourceMappingURL=json.d.ts.map

package/dist/tools/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/tools/json.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,eAAO,MAAM,SAAS;;;;;;;;;;EAYpB,CAAC;AAQH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAYxB,CAAC"}

package/dist/tools/json.js

@@ -0,0 +1,42 @@
+/**
+ * JSON tools - parse and stringify JSON
+ */
+import { z } from 'zod';
+import { tool } from '../tool';
+const jsonParseParams = z.object({
+    json: z.string().describe('The JSON string to parse'),
+});
+export const jsonParse = tool({
+    name: 'json_parse',
+    description: 'Parse a JSON string into an object. Returns an error if the JSON is invalid.',
+    parameters: jsonParseParams,
+    execute: async ({ json }) => {
+        try {
+            const result = JSON.parse(json);
+            return { result, valid: true };
+        }
+        catch (err) {
+            return { error: err.message, valid: false };
+        }
+    },
+});
+const jsonStringifyParams = z.object({
+    data: z.unknown().describe('The data to convert to JSON'),
+    pretty: z.boolean().optional().describe('Format with indentation (default: false)'),
+    indent: z.number().int().min(0).max(8).optional().describe('Indentation spaces (default: 2)'),
+});
+export const jsonStringify = tool({
+    name: 'json_stringify',
+    description: 'Convert a value to a JSON string. Optionally format with indentation.',
+    parameters: jsonStringifyParams,
+    execute: async ({ data, pretty = false, indent = 2 }) => {
+        try {
+            const result = pretty ? JSON.stringify(data, null, indent) : JSON.stringify(data);
+            return { result, pretty };
+        }
+        catch (err) {
+            return { error: err.message };
+        }
+    },
+});
+//# sourceMappingURL=json.js.map

package/dist/tools/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/tools/json.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;CACtD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC;IAC5B,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,8EAA8E;IAC3F,UAAU,EAAE,eAAe;IAC3B,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;QAC1B,IAAI,CAAC;YACH,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACzC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACjC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,EAAE,KAAK,EAAG,GAAa,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACzD,CAAC;IACH,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IACzD,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0CAA0C,CAAC;IACnF,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iCAAiC,CAAC;CAC9F,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC;IAChC,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,uEAAuE;IACpF,UAAU,EAAE,mBAAmB;IAC/B,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,EAAE;QACtD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAClF,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAC5B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,EAAE,KAAK,EAAG,GAAa,CAAC,OAAO,EAAE,CAAC;QAC3C,CAAC;IACH,CAAC;CACF,CAAC,CAAC"}

package/dist/tools/random.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Random tools - generate random numbers and strings
+ */
+export declare const randomNumber: import("@cogitator-ai/types").Tool<{
+    integer?: boolean | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+}, {
+    error: string;
+    min: number;
+    max: number;
+    result?: undefined;
+    integer?: undefined;
+} | {
+    result: number;
+    min: number;
+    max: number;
+    integer: boolean;
+    error?: undefined;
+}>;
+export declare const randomString: import("@cogitator-ai/types").Tool<{
+    length: number;
+    charset?: "numeric" | "alphanumeric" | "alpha" | "hex" | undefined;
+}, {
+    result: string;
+    length: number;
+    charset: "numeric" | "alphanumeric" | "alpha" | "hex";
+}>;
+//# sourceMappingURL=random.d.ts.map

package/dist/tools/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/tools/random.ts"],"names":[],"mappings":"AAAA;;GAEG;AAYH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAYvB,CAAC;AAeH,eAAO,MAAM,YAAY;;;;;;;EAsBvB,CAAC"}

package/dist/tools/random.js

@@ -0,0 +1,56 @@
+/**
+ * Random tools - generate random numbers and strings
+ */
+import { randomBytes } from 'node:crypto';
+import { z } from 'zod';
+import { tool } from '../tool';
+const randomNumberParams = z.object({
+    min: z.number().optional().describe('Minimum value (default: 0)'),
+    max: z.number().optional().describe('Maximum value (default: 1)'),
+    integer: z.boolean().optional().describe('Return integer only (default: false)'),
+});
+export const randomNumber = tool({
+    name: 'random_number',
+    description: 'Generate a random number within a range.',
+    parameters: randomNumberParams,
+    execute: async ({ min = 0, max = 1, integer = false }) => {
+        if (min >= max) {
+            return { error: 'min must be less than max', min, max };
+        }
+        const value = Math.random() * (max - min) + min;
+        const result = integer ? Math.floor(value) : value;
+        return { result, min, max, integer };
+    },
+});
+const ALPHANUMERIC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+const ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+const NUMERIC = '0123456789';
+const HEX = '0123456789abcdef';
+const randomStringParams = z.object({
+    length: z.number().int().min(1).max(1000).describe('Length of the string to generate'),
+    charset: z
+        .enum(['alphanumeric', 'alpha', 'numeric', 'hex'])
+        .optional()
+        .describe('Character set to use (default: alphanumeric)'),
+});
+export const randomString = tool({
+    name: 'random_string',
+    description: 'Generate a cryptographically secure random string. Available charsets: alphanumeric, alpha, numeric, hex.',
+    parameters: randomStringParams,
+    execute: async ({ length, charset = 'alphanumeric' }) => {
+        const chars = charset === 'alpha'
+            ? ALPHA
+            : charset === 'numeric'
+                ? NUMERIC
+                : charset === 'hex'
+                    ? HEX
+                    : ALPHANUMERIC;
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars[bytes[i] % chars.length];
+        }
+        return { result, length, charset };
+    },
+});
+//# sourceMappingURL=random.js.map

package/dist/tools/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src/tools/random.ts"],"names":[],"mappings":"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"}

package/dist/tools/regex.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Regex tools - pattern matching and replacement
+ */
+export declare const regexMatch: import("@cogitator-ai/types").Tool<{
+    text: string;
+    pattern: string;
+    flags?: string | undefined;
+}, {
+    matches: {
+        match: string;
+        index: number;
+        groups?: Record<string, string>;
+    }[];
+    count: number;
+    pattern: string;
+    flags: string;
+    error?: undefined;
+} | {
+    error: string;
+    pattern: string;
+    matches?: undefined;
+    count?: undefined;
+    flags?: undefined;
+}>;
+export declare const regexReplace: import("@cogitator-ai/types").Tool<{
+    text: string;
+    pattern: string;
+    replacement: string;
+    flags?: string | undefined;
+}, {
+    result: string;
+    replacements: number;
+    pattern: string;
+    flags: string;
+    error?: undefined;
+} | {
+    error: string;
+    pattern: string;
+    result?: undefined;
+    replacements?: undefined;
+    flags?: undefined;
+}>;
+//# sourceMappingURL=regex.d.ts.map

package/dist/tools/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/tools/regex.ts"],"names":[],"mappings":"AAAA;;GAEG;AAWH,eAAO,MAAM,UAAU;;;;;;eAQO,MAAM;eAAS,MAAM;iBAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;EA2BlF,CAAC;AASH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;EAevB,CAAC"}

package/dist/tools/regex.js

@@ -0,0 +1,68 @@
+/**
+ * Regex tools - pattern matching and replacement
+ */
+import { z } from 'zod';
+import { tool } from '../tool';
+const regexMatchParams = z.object({
+    text: z.string().describe('The text to search in'),
+    pattern: z.string().describe('Regular expression pattern'),
+    flags: z.string().optional().describe('Regex flags (default: "g"). Common: g=global, i=case-insensitive, m=multiline'),
+});
+export const regexMatch = tool({
+    name: 'regex_match',
+    description: 'Find all matches of a regular expression in text. Returns an array of matches with their positions.',
+    parameters: regexMatchParams,
+    execute: async ({ text, pattern, flags = 'g' }) => {
+        try {
+            const regex = new RegExp(pattern, flags);
+            const matches = [];
+            if (flags.includes('g')) {
+                let match;
+                while ((match = regex.exec(text)) !== null) {
+                    matches.push({
+                        match: match[0],
+                        index: match.index,
+                        groups: match.groups,
+                    });
+                }
+            }
+            else {
+                const match = regex.exec(text);
+                if (match) {
+                    matches.push({
+                        match: match[0],
+                        index: match.index,
+                        groups: match.groups,
+                    });
+                }
+            }
+            return { matches, count: matches.length, pattern, flags };
+        }
+        catch (err) {
+            return { error: err.message, pattern };
+        }
+    },
+});
+const regexReplaceParams = z.object({
+    text: z.string().describe('The text to perform replacement on'),
+    pattern: z.string().describe('Regular expression pattern to match'),
+    replacement: z.string().describe('Replacement string. Use $1, $2, etc. for capture groups'),
+    flags: z.string().optional().describe('Regex flags (default: "g")'),
+});
+export const regexReplace = tool({
+    name: 'regex_replace',
+    description: 'Replace matches of a regular expression in text. Use $1, $2, etc. to reference capture groups in the replacement.',
+    parameters: regexReplaceParams,
+    execute: async ({ text, pattern, replacement, flags = 'g' }) => {
+        try {
+            const regex = new RegExp(pattern, flags);
+            const result = text.replace(regex, replacement);
+            const replacements = (text.match(regex) || []).length;
+            return { result, replacements, pattern, flags };
+        }
+        catch (err) {
+            return { error: err.message, pattern };
+        }
+    },
+});
+//# sourceMappingURL=regex.js.map

package/dist/tools/regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.js","sourceRoot":"","sources":["../../src/tools/regex.ts"],"names":[],"mappings":"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"}