@mastra/dane 0.0.2-alpha.31 → 0.0.2-alpha.32

package/dist/mastra/agents/index.js

@@ -0,0 +1,106 @@
+import { Agent } from '@mastra/core';
+import { config } from '../../config/index.js';
+import { browserTool, googleSearch } from '../tools/browser.js';
+import { listEvents } from '../tools/calendar.js';
+import { crawl } from '../tools/crawl.js';
+import { execaTool } from '../tools/execa.js';
+import { fsTool } from '../tools/fs.js';
+import { imageTool } from '../tools/image.js';
+import { readPDF } from '../tools/pdf.js';
+import { activeDistTag, pnpmBuild, pnpmChangesetPublish, pnpmChangesetStatus } from '../tools/pnpm.js';
+const getBaseModelConfig = () => ({
+    provider: 'ANTHROPIC',
+    toolChoice: 'auto',
+    name: 'claude-3-5-sonnet-20241022',
+    apiKey: config.getAnthropicApiKey(),
+});
+export const daneCommitMessage = new Agent({
+    name: 'DaneCommitMessage',
+    instructions: `
+    You are Dane, the ultimate GitHub operator.
+    You help engineers generate commit messages.
+
+    GENERATE A SCOPE FOR THE COMMIT MESSAGE IF NECESSARY.
+    FIGURE OUT THE BEST TOP LEVEL SEMANTIC MATCH TO USE AS THE SCOPE.
+    `,
+    model: getBaseModelConfig(),
+});
+export const daneIssueLabeler = new Agent({
+    name: 'DaneIssueLabeler',
+    instructions: `
+    You are Dane, the ultimate GitHub operator.
+    You help engineers label their issues.
+    `,
+    model: getBaseModelConfig(),
+});
+export const danePackagePublisher = new Agent({
+    name: 'DanePackagePublisher',
+    instructions: `
+    You are Dane, the ultimate node module publisher.
+    You help engineers publish their pnpm changesets.
+    `,
+    model: getBaseModelConfig(),
+    tools: {
+        execaTool,
+        pnpmBuild,
+        pnpmChangesetPublish,
+        pnpmChangesetStatus,
+        activeDistTag,
+    },
+});
+export const dane = new Agent({
+    name: 'Dane',
+    instructions: `
+    You are Dane, my assistant and one of my best friends. We are an ace team!
+    You help me with my code, write tests, and even deploy my code to the cloud!
+
+    DO NOT ATTEMPT TO USE GENERAL KNOWLEDGE! We are only as good as the tools we use.
+
+    # Our tools:
+
+    ## readPDF
+    Makes you a powerful agent capable of reading PDF files.
+
+    ## fsTool
+    Makes you a powerful agent capable of reading and writing files to the local filesystem.
+
+    ## execaTool
+    Makes you a powerful agent capabale of executing files on the local system.
+
+    ## googleSearch
+    Makes you a powerful agent capabale answering all questions by finding the answer on Google search.
+    Pass the query as a JS object. If you have links, ALWAYS CITE YOUR SOURCES.
+
+    ## browserTool
+    Makes you a powerful agent capable of scraping the web. Pass the url as a JS object.
+
+    ## listEvents
+    Makes you a powerful agent capable of listing events on a calendar. When using this tool ONLY RETURN RELEVANT EVENTS.
+    DO NOT ATTEMPT TO DO ANYTHING MORE.
+
+    ## crawl
+    Use this when the user asks you to crawl. CRAWL is the signal to use this tool.
+    Makes you a powerful agent capable of crawling a site and extracting markdown metadata.
+    The data will be stored in a database if it is not already there. Confirm that it is sucessful.
+    The crawled data will be returned in the response on the 'crawlData' field.
+
+    ## imageTool
+    Makes you a powerful agent capable of generating images and saving them to disk. Pass the directory and an image prompt.
+
+    # Rules
+    * DO NOT ATTEMPT TO USE GENERAL KNOWLEDGE. Use the 'googleSearch' tool to find the answer.
+    * Don't reference tools when you communicate with the user. Do not mention what tools you are using.
+    * Tell the user what you are doing.
+    `,
+    model: getBaseModelConfig(),
+    tools: {
+        fsTool,
+        execaTool,
+        browserTool,
+        googleSearch,
+        readPDF,
+        listEvents,
+        crawl,
+        imageTool,
+    },
+});

package/dist/mastra/index.d.ts

@@ -0,0 +1,318 @@
+import { Mastra } from '@mastra/core';
+export declare const mastra: Mastra<{
+    [x: string]: import("@mastra/core").SyncAction<any, any, any, any>;
+}, {
+    dane: import("@mastra/core").Agent<{
+        fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{
+            action: import("zod").ZodString;
+            file: import("zod").ZodString;
+            data: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            data: string;
+            action: string;
+            file: string;
+        }, {
+            data: string;
+            action: string;
+            file: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            action: import("zod").ZodString;
+            file: import("zod").ZodString;
+            data: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            data: string;
+            action: string;
+            file: string;
+        }, {
+            data: string;
+            action: string;
+            file: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        execaTool: import("@mastra/core").Tool<"execaTool", import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        browserTool: import("@mastra/core").Tool<"browserTool", import("zod").ZodObject<{
+            url: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            url: string;
+        }, {
+            url: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            url: string;
+        }, {
+            url: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        googleSearch: import("@mastra/core").Tool<"googleSearch", import("zod").ZodObject<{
+            query: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            query: string;
+        }, {
+            query: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            query: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            query: string;
+        }, {
+            query: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        readPDF: import("@mastra/core").Tool<"readPDF", import("zod").ZodObject<{
+            pdfPath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            pdfPath: string;
+        }, {
+            pdfPath: string;
+        }>, import("zod").ZodObject<{
+            content: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            content: string;
+        }, {
+            content: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            pdfPath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            pdfPath: string;
+        }, {
+            pdfPath: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        listEvents: import("@mastra/core").Tool<"listEvents", import("zod").ZodObject<{
+            startDate: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            startDate: string;
+        }, {
+            startDate: string;
+        }>, import("zod").ZodObject<{
+            content: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            content: string;
+        }, {
+            content: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            startDate: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            startDate: string;
+        }, {
+            startDate: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        crawl: import("@mastra/core").Tool<"crawler", import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            pathRegex: import("zod").ZodNullable<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            url: string;
+            limit: number;
+            pathRegex: string | null;
+        }, {
+            url: string;
+            pathRegex: string | null;
+            limit?: number | undefined;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+            crawlData: import("zod").ZodAny;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+            crawlData?: any;
+        }, {
+            message: string;
+            crawlData?: any;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            pathRegex: import("zod").ZodNullable<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            url: string;
+            limit: number;
+            pathRegex: string | null;
+        }, {
+            url: string;
+            pathRegex: string | null;
+            limit?: number | undefined;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        imageTool: import("@mastra/core").Tool<"imageTool", import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            prompt: string;
+        }, {
+            directory: string;
+            prompt: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            prompt: string;
+        }, {
+            directory: string;
+            prompt: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+    }>;
+    danePackagePublisher: import("@mastra/core").Agent<{
+        execaTool: import("@mastra/core").Tool<"execaTool", import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            packagePath: string;
+        }, {
+            name: string;
+            packagePath: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            packagePath: string;
+        }, {
+            name: string;
+            packagePath: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+        pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+            message: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string[];
+        }, {
+            message: string[];
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+        activeDistTag: import("@mastra/core").Tool<"activeDistTag", import("zod").ZodObject<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: string;
+        }, {
+            packagePath: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: string;
+        }, {
+            packagePath: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+    }>;
+    daneIssueLabeler: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+    daneCommitMessage: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+}, {
+    message: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        resourceid: import("zod").ZodString;
+        threadId: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        resourceid: string;
+        threadId: string;
+    }, {
+        resourceid: string;
+        threadId: string;
+    }>>;
+    githubIssueLabeler: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        owner: import("zod").ZodString;
+        issue_number: import("zod").ZodNumber;
+    }, "strip", import("zod").ZodTypeAny, {
+        repo: string;
+        owner: string;
+        issue_number: number;
+    }, {
+        repo: string;
+        owner: string;
+        issue_number: number;
+    }>>;
+    commitMessage: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        repoPath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        repoPath: string;
+    }, {
+        repoPath: string;
+    }>>;
+    packagePublisher: import("@mastra/core").Workflow<any, any>;
+}, import("@mastra/core").BaseLogger<import("@mastra/core").BaseLogMessage>>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mastra/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAatC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAuBjB,CAAC"}

package/dist/mastra/index.js

@@ -0,0 +1,34 @@
+import { Mastra } from '@mastra/core';
+import { PostgresEngine } from '@mastra/engine';
+import { UpstashKVMemory } from '@mastra/memory';
+import { dane, daneCommitMessage, daneIssueLabeler, danePackagePublisher } from './agents/index.js';
+import { firecrawl } from './integrations/index.js';
+import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.js';
+import { packagePublisher } from './workflows/publish-packages.js';
+const engine = new PostgresEngine({
+    url: 'postgres://postgres:postgres@localhost:5433/mastra',
+});
+export const mastra = new Mastra({
+    agents: {
+        dane,
+        danePackagePublisher,
+        daneIssueLabeler,
+        daneCommitMessage,
+    },
+    engine,
+    memory: new UpstashKVMemory({
+        url: 'http://localhost:8079',
+        token: `example_token`,
+        maxTokens: 39000,
+    }),
+    workflows: {
+        message: messageWorkflow,
+        githubIssueLabeler: githubIssueLabeler,
+        commitMessage: commitMessageGenerator,
+        packagePublisher: packagePublisher,
+    },
+    logger: false,
+    syncs: {
+        ...firecrawl.getSyncs(),
+    },
+});

package/dist/mastra/integrations/index.d.ts

@@ -0,0 +1,7 @@
+import { FirecrawlIntegration } from "@mastra/firecrawl";
+import { GithubIntegration } from "@mastra/github";
+import { StabilityAiIntegration } from "@mastra/stabilityai";
+export declare const firecrawl: FirecrawlIntegration;
+export declare const github: GithubIntegration;
+export declare const stabilityai: StabilityAiIntegration;
+//# sourceMappingURL=index.d.ts.map

package/dist/mastra/integrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/integrations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAc7D,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH,eAAO,MAAM,MAAM,mBAIjB,CAAC;AAEH,eAAO,MAAM,WAAW,wBAItB,CAAC"}

package/dist/mastra/integrations/index.js

@@ -0,0 +1,29 @@
+import { FirecrawlIntegration } from "@mastra/firecrawl";
+import { GithubIntegration } from "@mastra/github";
+import { StabilityAiIntegration } from "@mastra/stabilityai";
+import { config } from "../../config/index.js";
+// Helper function to get key from config or env
+const getApiKey = (configKey, envKey) => {
+    const configValue = config.get(configKey);
+    if (configValue)
+        return configValue;
+    const envValue = process.env[envKey];
+    if (envValue)
+        return envValue;
+    return '';
+};
+export const firecrawl = new FirecrawlIntegration({
+    config: {
+        API_KEY: getApiKey('FIRECRAWL_API_KEY', 'FIRECRAWL_API_KEY'),
+    },
+});
+export const github = new GithubIntegration({
+    config: {
+        PERSONAL_ACCESS_TOKEN: getApiKey('GITHUB_PERSONAL_ACCESS_TOKEN', 'GITHUB_PERSONAL_ACCESS_TOKEN'),
+    }
+});
+export const stabilityai = new StabilityAiIntegration({
+    config: {
+        API_KEY: getApiKey('STABILITYAI_API_KEY', 'STABILITYAI_API_KEY'),
+    }
+});

package/dist/mastra/tools/browser.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const browserTool: import("@mastra/core").Tool<"browserTool", z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const googleSearch: import("@mastra/core").Tool<"googleSearch", z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+//# sourceMappingURL=browser.d.ts.map

package/dist/mastra/tools/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/browser.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;iDAoDtB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;iDAqEvB,CAAC"}

package/dist/mastra/tools/browser.js

@@ -0,0 +1,116 @@
+import { createTool } from '@mastra/core';
+import { MDocument } from '@mastra/rag';
+import chalk from 'chalk';
+import { chromium } from 'playwright-core';
+import { z } from 'zod';
+export const browserTool = createTool({
+    id: 'browserTool',
+    name: 'Browser Tool',
+    description: 'Browser Tool, opens a browser and navigates to a url capturing the content',
+    inputSchema: z.object({
+        url: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { url } }) => {
+        try {
+            const browser = await chromium.launch({
+                headless: true,
+            });
+            const page = await browser.newPage();
+            await page.goto(url);
+            const docs = MDocument.fromHTML(await page.content());
+            await docs.chunk({
+                strategy: 'html',
+                size: 300,
+                sections: [
+                    ['h1', 'Header 1'],
+                    ['h2', 'Header 2'],
+                    ['h3', 'Header 3'],
+                    ['h4', 'Header 4'],
+                    ['h5', 'Header 5'],
+                    ['h6', 'Header 6'],
+                    ['p', 'Paragraph'],
+                ],
+            });
+            await page.close();
+            await browser.close();
+            if (!docs.getText().length) {
+                return { message: 'No content' };
+            }
+            return { message: docs.getText().join('\n') };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const googleSearch = createTool({
+    id: 'googleSearch',
+    name: 'Google Search',
+    description: 'Google Search. Passes the query to Google and returns the search results.',
+    inputSchema: z.object({
+        query: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { query } }) => {
+        let browser;
+        try {
+            browser = await chromium.launch({
+                headless: true,
+            });
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: 'Error' };
+        }
+        try {
+            const page = await browser.newPage();
+            await page.goto(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
+            console.log(`\n`);
+            console.log(chalk.blue('Waiting for search results...'));
+            try {
+                await page.click('button:has-text("Accept all")', { timeout: 5000 });
+            }
+            catch (e) {
+                // Cookie dialog didn't appear, continue
+            }
+            // Wait for results and click first organic result
+            await page.waitForSelector('#search');
+            const text = await page.evaluate(() => {
+                const links = [];
+                const searchResults = document.querySelectorAll('div.g a');
+                searchResults.forEach(link => {
+                    const href = link.getAttribute('href');
+                    if (href && href.startsWith('http')) {
+                        links.push(href);
+                    }
+                });
+                return links;
+            });
+            await page.close();
+            await browser.close();
+            if (!text.length) {
+                return { message: 'No results' };
+            }
+            return { message: text.join('\n') };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: `Error` };
+        }
+    },
+});