langchain 0.0.200 → 0.0.202

package/dist/tools/gmail/search.cjs

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GmailSearch = void 0;
+const zod_1 = require("zod");
+const base_js_1 = require("./base.cjs");
+const descriptions_js_1 = require("./descriptions.cjs");
+class GmailSearch extends base_js_1.GmailBaseTool {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "search_gmail"
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: zod_1.z.object({
+                query: zod_1.z.string(),
+                maxResults: zod_1.z.number().optional(),
+                resource: zod_1.z.enum(["messages", "threads"]).optional(),
+            })
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: descriptions_js_1.SEARCH_DESCRIPTION
+        });
+    }
+    async _call(arg) {
+        const { query, maxResults = 10, resource = "messages" } = arg;
+        const response = await this.gmail.users.messages.list({
+            userId: "me",
+            q: query,
+            maxResults,
+        });
+        const { data } = response;
+        if (!data) {
+            throw new Error("No data returned from Gmail");
+        }
+        const { messages } = data;
+        if (!messages) {
+            throw new Error("No messages returned from Gmail");
+        }
+        if (resource === "messages") {
+            const parsedMessages = await this.parseMessages(messages);
+            return `Result for the query ${query}:\n${JSON.stringify(parsedMessages)}`;
+        }
+        else if (resource === "threads") {
+            const parsedThreads = await this.parseThreads(messages);
+            return `Result for the query ${query}:\n${JSON.stringify(parsedThreads)}`;
+        }
+        throw new Error(`Invalid resource: ${resource}`);
+    }
+    async parseMessages(messages) {
+        const parsedMessages = await Promise.all(messages.map(async (message) => {
+            const messageData = await this.gmail.users.messages.get({
+                userId: "me",
+                format: "raw",
+                id: message.id ?? "",
+            });
+            const headers = messageData.data.payload?.headers || [];
+            const subject = headers.find((header) => header.name === "Subject");
+            const sender = headers.find((header) => header.name === "From");
+            let body = "";
+            if (messageData.data.payload?.parts) {
+                body = messageData.data.payload.parts
+                    .map((part) => part.body?.data ?? "")
+                    .join("");
+            }
+            else if (messageData.data.payload?.body?.data) {
+                body = messageData.data.payload.body.data;
+            }
+            return {
+                id: message.id,
+                threadId: message.threadId,
+                snippet: message.snippet,
+                body,
+                subject,
+                sender,
+            };
+        }));
+        return parsedMessages;
+    }
+    async parseThreads(threads) {
+        const parsedThreads = await Promise.all(threads.map(async (thread) => {
+            const threadData = await this.gmail.users.threads.get({
+                userId: "me",
+                format: "raw",
+                id: thread.id ?? "",
+            });
+            const headers = threadData.data.messages?.[0]?.payload?.headers || [];
+            const subject = headers.find((header) => header.name === "Subject");
+            const sender = headers.find((header) => header.name === "From");
+            let body = "";
+            if (threadData.data.messages?.[0]?.payload?.parts) {
+                body = threadData.data.messages[0].payload.parts
+                    .map((part) => part.body?.data ?? "")
+                    .join("");
+            }
+            else if (threadData.data.messages?.[0]?.payload?.body?.data) {
+                body = threadData.data.messages[0].payload.body.data;
+            }
+            return {
+                id: thread.id,
+                snippet: thread.snippet,
+                body,
+                subject,
+                sender,
+            };
+        }));
+        return parsedThreads;
+    }
+}
+exports.GmailSearch = GmailSearch;

package/dist/tools/gmail/search.d.ts

@@ -0,0 +1,29 @@
+import { gmail_v1 } from "googleapis";
+import { z } from "zod";
+import { GmailBaseTool, GmailBaseToolParams } from "./base.js";
+export declare class GmailSearch extends GmailBaseTool {
+    name: string;
+    schema: z.ZodObject<{
+        query: z.ZodString;
+        maxResults: z.ZodOptional<z.ZodNumber>;
+        resource: z.ZodOptional<z.ZodEnum<["messages", "threads"]>>;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        maxResults?: number | undefined;
+        resource?: "messages" | "threads" | undefined;
+    }, {
+        query: string;
+        maxResults?: number | undefined;
+        resource?: "messages" | "threads" | undefined;
+    }>;
+    description: string;
+    constructor(fields?: GmailBaseToolParams);
+    _call(arg: z.output<typeof this.schema>): Promise<string>;
+    parseMessages(messages: gmail_v1.Schema$Message[]): Promise<gmail_v1.Schema$Message[]>;
+    parseThreads(threads: gmail_v1.Schema$Thread[]): Promise<gmail_v1.Schema$Thread[]>;
+}
+export type SearchSchema = {
+    query: string;
+    maxResults?: number;
+    resource?: "messages" | "threads";
+};

package/dist/tools/gmail/search.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { GmailBaseTool } from "./base.js";
+import { SEARCH_DESCRIPTION } from "./descriptions.js";
+export class GmailSearch extends GmailBaseTool {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "search_gmail"
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: z.object({
+                query: z.string(),
+                maxResults: z.number().optional(),
+                resource: z.enum(["messages", "threads"]).optional(),
+            })
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: SEARCH_DESCRIPTION
+        });
+    }
+    async _call(arg) {
+        const { query, maxResults = 10, resource = "messages" } = arg;
+        const response = await this.gmail.users.messages.list({
+            userId: "me",
+            q: query,
+            maxResults,
+        });
+        const { data } = response;
+        if (!data) {
+            throw new Error("No data returned from Gmail");
+        }
+        const { messages } = data;
+        if (!messages) {
+            throw new Error("No messages returned from Gmail");
+        }
+        if (resource === "messages") {
+            const parsedMessages = await this.parseMessages(messages);
+            return `Result for the query ${query}:\n${JSON.stringify(parsedMessages)}`;
+        }
+        else if (resource === "threads") {
+            const parsedThreads = await this.parseThreads(messages);
+            return `Result for the query ${query}:\n${JSON.stringify(parsedThreads)}`;
+        }
+        throw new Error(`Invalid resource: ${resource}`);
+    }
+    async parseMessages(messages) {
+        const parsedMessages = await Promise.all(messages.map(async (message) => {
+            const messageData = await this.gmail.users.messages.get({
+                userId: "me",
+                format: "raw",
+                id: message.id ?? "",
+            });
+            const headers = messageData.data.payload?.headers || [];
+            const subject = headers.find((header) => header.name === "Subject");
+            const sender = headers.find((header) => header.name === "From");
+            let body = "";
+            if (messageData.data.payload?.parts) {
+                body = messageData.data.payload.parts
+                    .map((part) => part.body?.data ?? "")
+                    .join("");
+            }
+            else if (messageData.data.payload?.body?.data) {
+                body = messageData.data.payload.body.data;
+            }
+            return {
+                id: message.id,
+                threadId: message.threadId,
+                snippet: message.snippet,
+                body,
+                subject,
+                sender,
+            };
+        }));
+        return parsedMessages;
+    }
+    async parseThreads(threads) {
+        const parsedThreads = await Promise.all(threads.map(async (thread) => {
+            const threadData = await this.gmail.users.threads.get({
+                userId: "me",
+                format: "raw",
+                id: thread.id ?? "",
+            });
+            const headers = threadData.data.messages?.[0]?.payload?.headers || [];
+            const subject = headers.find((header) => header.name === "Subject");
+            const sender = headers.find((header) => header.name === "From");
+            let body = "";
+            if (threadData.data.messages?.[0]?.payload?.parts) {
+                body = threadData.data.messages[0].payload.parts
+                    .map((part) => part.body?.data ?? "")
+                    .join("");
+            }
+            else if (threadData.data.messages?.[0]?.payload?.body?.data) {
+                body = threadData.data.messages[0].payload.body.data;
+            }
+            return {
+                id: thread.id,
+                snippet: thread.snippet,
+                body,
+                subject,
+                sender,
+            };
+        }));
+        return parsedThreads;
+    }
+}

package/dist/tools/gmail/send_message.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GmailSendMessage = void 0;
+const zod_1 = require("zod");
+const base_js_1 = require("./base.cjs");
+const descriptions_js_1 = require("./descriptions.cjs");
+class GmailSendMessage extends base_js_1.GmailBaseTool {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gmail_send_message"
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: zod_1.z.object({
+                message: zod_1.z.string(),
+                to: zod_1.z.array(zod_1.z.string()),
+                subject: zod_1.z.string(),
+                cc: zod_1.z.array(zod_1.z.string()).optional(),
+                bcc: zod_1.z.array(zod_1.z.string()).optional(),
+            })
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: descriptions_js_1.GET_MESSAGE_DESCRIPTION
+        });
+    }
+    createEmailMessage({ message, to, subject, cc, bcc, }) {
+        const emailLines = [];
+        // Format the recipient(s)
+        const formatEmailList = (emails) => Array.isArray(emails) ? emails.join(",") : emails;
+        emailLines.push(`To: ${formatEmailList(to)}`);
+        if (cc)
+            emailLines.push(`Cc: ${formatEmailList(cc)}`);
+        if (bcc)
+            emailLines.push(`Bcc: ${formatEmailList(bcc)}`);
+        emailLines.push(`Subject: ${subject}`);
+        emailLines.push("");
+        emailLines.push(message);
+        // Convert the email message to base64url string
+        const email = emailLines.join("\r\n").trim();
+        // this encode may be an issue
+        return Buffer.from(email).toString("base64url");
+    }
+    async _call({ message, to, subject, cc, bcc, }) {
+        const rawMessage = this.createEmailMessage({
+            message,
+            to,
+            subject,
+            cc,
+            bcc,
+        });
+        try {
+            const response = await this.gmail.users.messages.send({
+                userId: "me",
+                requestBody: {
+                    raw: rawMessage,
+                },
+            });
+            return `Message sent. Message Id: ${response.data.id}`;
+        }
+        catch (error) {
+            throw new Error(`An error occurred while sending the message: ${error}`);
+        }
+    }
+}
+exports.GmailSendMessage = GmailSendMessage;

package/dist/tools/gmail/send_message.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { GmailBaseTool, GmailBaseToolParams } from "./base.js";
+export declare class GmailSendMessage extends GmailBaseTool {
+    name: string;
+    schema: z.ZodObject<{
+        message: z.ZodString;
+        to: z.ZodArray<z.ZodString, "many">;
+        subject: z.ZodString;
+        cc: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        bcc: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        subject: string;
+        to: string[];
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+    }, {
+        message: string;
+        subject: string;
+        to: string[];
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+    }>;
+    description: string;
+    constructor(fields?: GmailBaseToolParams);
+    private createEmailMessage;
+    _call({ message, to, subject, cc, bcc, }: z.output<typeof this.schema>): Promise<string>;
+}
+export type SendMessageSchema = {
+    message: string;
+    to: string[];
+    subject: string;
+    cc?: string[];
+    bcc?: string[];
+};

package/dist/tools/gmail/send_message.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { GmailBaseTool } from "./base.js";
+import { GET_MESSAGE_DESCRIPTION } from "./descriptions.js";
+export class GmailSendMessage extends GmailBaseTool {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gmail_send_message"
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: z.object({
+                message: z.string(),
+                to: z.array(z.string()),
+                subject: z.string(),
+                cc: z.array(z.string()).optional(),
+                bcc: z.array(z.string()).optional(),
+            })
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: GET_MESSAGE_DESCRIPTION
+        });
+    }
+    createEmailMessage({ message, to, subject, cc, bcc, }) {
+        const emailLines = [];
+        // Format the recipient(s)
+        const formatEmailList = (emails) => Array.isArray(emails) ? emails.join(",") : emails;
+        emailLines.push(`To: ${formatEmailList(to)}`);
+        if (cc)
+            emailLines.push(`Cc: ${formatEmailList(cc)}`);
+        if (bcc)
+            emailLines.push(`Bcc: ${formatEmailList(bcc)}`);
+        emailLines.push(`Subject: ${subject}`);
+        emailLines.push("");
+        emailLines.push(message);
+        // Convert the email message to base64url string
+        const email = emailLines.join("\r\n").trim();
+        // this encode may be an issue
+        return Buffer.from(email).toString("base64url");
+    }
+    async _call({ message, to, subject, cc, bcc, }) {
+        const rawMessage = this.createEmailMessage({
+            message,
+            to,
+            subject,
+            cc,
+            bcc,
+        });
+        try {
+            const response = await this.gmail.users.messages.send({
+                userId: "me",
+                requestBody: {
+                    raw: rawMessage,
+                },
+            });
+            return `Message sent. Message Id: ${response.data.id}`;
+        }
+        catch (error) {
+            throw new Error(`An error occurred while sending the message: ${error}`);
+        }
+    }
+}

package/dist/tools/wolframalpha.cjs

@@ -41,7 +41,7 @@ class WolframAlphaTool extends base_js_1.Tool {
         return "WolframAlphaTool";
     }
     async _call(query) {
-        const url = `https://www.wolframalpha.com/api/v1/llm-api?appid=${this.appid}&input=${query}`;
+        const url = `https://www.wolframalpha.com/api/v1/llm-api?appid=${this.appid}&input=${encodeURIComponent(query)}`;
         const res = await fetch(url);
         return res.text();
     }

package/dist/tools/wolframalpha.js

@@ -38,7 +38,7 @@ export class WolframAlphaTool extends Tool {
         return "WolframAlphaTool";
     }
     async _call(query) {
-        const url = `https://www.wolframalpha.com/api/v1/llm-api?appid=${this.appid}&input=${query}`;
+        const url = `https://www.wolframalpha.com/api/v1/llm-api?appid=${this.appid}&input=${encodeURIComponent(query)}`;
         const res = await fetch(url);
         return res.text();
     }

package/dist/util/stream.cjs

@@ -1,87 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableReadableStream = void 0;
-/*
- * Support async iterator syntax for ReadableStreams in all environments.
- * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-class IterableReadableStream extends ReadableStream {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "reader", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    ensureReader() {
-        if (!this.reader) {
-            this.reader = this.getReader();
-        }
-    }
-    async next() {
-        this.ensureReader();
-        try {
-            const result = await this.reader.read();
-            if (result.done)
-                this.reader.releaseLock(); // release lock when stream becomes closed
-            return {
-                done: result.done,
-                value: result.value, // Cloudflare Workers typing fix
-            };
-        }
-        catch (e) {
-            this.reader.releaseLock(); // release lock when stream becomes errored
-            throw e;
-        }
-    }
-    async return() {
-        this.ensureReader();
-        const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
-        this.reader.releaseLock(); // release lock first
-        await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    static fromReadableStream(stream) {
-        // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
-        const reader = stream.getReader();
-        return new IterableReadableStream({
-            start(controller) {
-                return pump();
-                function pump() {
-                    return reader.read().then(({ done, value }) => {
-                        // When no more data needs to be consumed, close the stream
-                        if (done) {
-                            controller.close();
-                            return;
-                        }
-                        // Enqueue the next data chunk into our target stream
-                        controller.enqueue(value);
-                        return pump();
-                    });
-                }
-            },
-            cancel() {
-                reader.releaseLock();
-            },
-        });
-    }
-    static fromAsyncGenerator(generator) {
-        return new IterableReadableStream({
-            async pull(controller) {
-                const { value, done } = await generator.next();
-                // When no more data needs to be consumed, close the stream
-                if (done) {
-                    controller.close();
-                }
-                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
-                controller.enqueue(value);
-            },
-        });
-    }
-}
-exports.IterableReadableStream = IterableReadableStream;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@langchain/core/utils/stream"), exports);

package/dist/util/stream.d.ts

@@ -1,15 +1 @@
-export declare class IterableReadableStream<T> extends ReadableStream<T> {
-    reader: ReadableStreamDefaultReader<T>;
-    ensureReader(): void;
-    next(): Promise<{
-        done: boolean;
-        value: T;
-    }>;
-    return(): Promise<{
-        done: boolean;
-        value: T;
-    }>;
-    [Symbol.asyncIterator](): this;
-    static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
-    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
-}
+export * from "@langchain/core/utils/stream";

package/dist/util/stream.js

@@ -1,83 +1 @@
-/*
- * Support async iterator syntax for ReadableStreams in all environments.
- * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-export class IterableReadableStream extends ReadableStream {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "reader", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    ensureReader() {
-        if (!this.reader) {
-            this.reader = this.getReader();
-        }
-    }
-    async next() {
-        this.ensureReader();
-        try {
-            const result = await this.reader.read();
-            if (result.done)
-                this.reader.releaseLock(); // release lock when stream becomes closed
-            return {
-                done: result.done,
-                value: result.value, // Cloudflare Workers typing fix
-            };
-        }
-        catch (e) {
-            this.reader.releaseLock(); // release lock when stream becomes errored
-            throw e;
-        }
-    }
-    async return() {
-        this.ensureReader();
-        const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
-        this.reader.releaseLock(); // release lock first
-        await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
-    }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    static fromReadableStream(stream) {
-        // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
-        const reader = stream.getReader();
-        return new IterableReadableStream({
-            start(controller) {
-                return pump();
-                function pump() {
-                    return reader.read().then(({ done, value }) => {
-                        // When no more data needs to be consumed, close the stream
-                        if (done) {
-                            controller.close();
-                            return;
-                        }
-                        // Enqueue the next data chunk into our target stream
-                        controller.enqueue(value);
-                        return pump();
-                    });
-                }
-            },
-            cancel() {
-                reader.releaseLock();
-            },
-        });
-    }
-    static fromAsyncGenerator(generator) {
-        return new IterableReadableStream({
-            async pull(controller) {
-                const { value, done } = await generator.next();
-                // When no more data needs to be consumed, close the stream
-                if (done) {
-                    controller.close();
-                }
-                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
-                controller.enqueue(value);
-            },
-        });
-    }
-}
+export * from "@langchain/core/utils/stream";

package/dist/vectorstores/xata.cjs

@@ -89,7 +89,7 @@ class XataVectorSearch extends base_js_1.VectorStore {
      * @returns Promise resolving to an array of tuples, each containing a Document and its score.
      */
     async similaritySearchVectorWithScore(query, k, filter) {
-        const records = await this.client.db[this.table].vectorSearch("embedding", query, {
+        const { records } = await this.client.db[this.table].vectorSearch("embedding", query, {
             size: k,
             filter,
         });