langchain 0.0.158 → 0.0.160

package/dist/chat_models/bedrock.cjs

@@ -161,20 +161,23 @@ class ChatBedrock extends base_js_1.SimpleChatModel {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(messages, options, runManager) {
-        const chunks = [];
-        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
-            chunks.push(chunk);
-        }
-        return chunks.map((chunk) => chunk.text).join("");
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        const provider = this.model.split(".")[0];
+    async _call(messages, options) {
         const service = "bedrock-runtime";
-        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
-        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const provider = this.model.split(".")[0];
+        const response = await this._signedFetch(messages, options, {
+            bedrockMethod: "invoke",
+            endpointHost,
+            provider,
+        });
+        const json = await response.json();
+        const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+        return text;
+    }
+    async _signedFetch(messages, options, fields) {
+        const { bedrockMethod, endpointHost, provider } = fields;
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${bedrockMethod}`);
         const request = new protocol_http_1.HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -202,8 +205,20 @@ class ChatBedrock extends base_js_1.SimpleChatModel {
             body: signedRequest.body,
             method: signedRequest.method,
         }));
+        return response;
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const bedrockMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const response = await this._signedFetch(messages, options, {
+            bedrockMethod,
+            endpointHost,
+            provider,
+        });
         if (response.status < 200 || response.status >= 300) {
-            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+            throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
         if (provider === "anthropic") {
             const reader = response.body?.getReader();

package/dist/chat_models/bedrock.d.ts

@@ -49,7 +49,12 @@ export declare class ChatBedrock extends SimpleChatModel implements BaseBedrockI
       Example:
         response = model.call("Tell me a joke.")
     */
-    _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _call(messages: BaseMessage[], options: this["ParsedCallOptions"]): Promise<string>;
+    _signedFetch(messages: BaseMessage[], options: this["ParsedCallOptions"], fields: {
+        bedrockMethod: "invoke" | "invoke-with-response-stream";
+        endpointHost: string;
+        provider: string;
+    }): Promise<Response>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _readChunks(reader: any): {
         [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;

package/dist/chat_models/bedrock.js

@@ -156,20 +156,23 @@ export class ChatBedrock extends SimpleChatModel {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(messages, options, runManager) {
-        const chunks = [];
-        for await (const chunk of this._streamResponseChunks(messages, options, runManager)) {
-            chunks.push(chunk);
-        }
-        return chunks.map((chunk) => chunk.text).join("");
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        const provider = this.model.split(".")[0];
+    async _call(messages, options) {
         const service = "bedrock-runtime";
-        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
-        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const provider = this.model.split(".")[0];
+        const response = await this._signedFetch(messages, options, {
+            bedrockMethod: "invoke",
+            endpointHost,
+            provider,
+        });
+        const json = await response.json();
+        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+        return text;
+    }
+    async _signedFetch(messages, options, fields) {
+        const { bedrockMethod, endpointHost, provider } = fields;
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, convertMessagesToPromptAnthropic(messages), this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${bedrockMethod}`);
         const request = new HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -197,8 +200,20 @@ export class ChatBedrock extends SimpleChatModel {
             body: signedRequest.body,
             method: signedRequest.method,
         }));
+        return response;
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const service = "bedrock-runtime";
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        const bedrockMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const response = await this._signedFetch(messages, options, {
+            bedrockMethod,
+            endpointHost,
+            provider,
+        });
         if (response.status < 200 || response.status >= 300) {
-            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+            throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
         if (provider === "anthropic") {
             const reader = response.body?.getReader();

package/dist/llms/bedrock.cjs

@@ -120,20 +120,23 @@ class Bedrock extends base_js_1.LLM {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(prompt, options, runManager) {
-        const chunks = [];
-        for await (const chunk of this._streamResponseChunks(prompt, options, runManager)) {
-            chunks.push(chunk);
-        }
-        return chunks.map((chunk) => chunk.text).join("");
-    }
-    async *_streamResponseChunks(prompt, options, runManager) {
-        const provider = this.model.split(".")[0];
+    async _call(prompt, options) {
         const service = "bedrock-runtime";
-        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
-        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const provider = this.model.split(".")[0];
+        const response = await this._signedFetch(prompt, options, {
+            bedrockMethod: "invoke",
+            endpointHost,
+            provider,
+        });
+        const json = await response.json();
+        const text = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+        return text;
+    }
+    async _signedFetch(prompt, options, fields) {
+        const { bedrockMethod, endpointHost, provider } = fields;
+        const inputBody = bedrock_js_1.BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${bedrockMethod}`);
         const request = new protocol_http_1.HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -161,8 +164,21 @@ class Bedrock extends base_js_1.LLM {
             body: signedRequest.body,
             method: signedRequest.method,
         }));
+        return response;
+    }
+    async *_streamResponseChunks(prompt, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const bedrockMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const service = "bedrock-runtime";
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        // Send request to AWS using the low-level fetch API
+        const response = await this._signedFetch(prompt, options, {
+            bedrockMethod,
+            endpointHost,
+            provider,
+        });
         if (response.status < 200 || response.status >= 300) {
-            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+            throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
         if (provider === "anthropic") {
             const reader = response.body?.getReader();

package/dist/llms/bedrock.d.ts

@@ -39,7 +39,12 @@ export declare class Bedrock extends LLM implements BaseBedrockInput {
       Example:
         response = model.call("Tell me a joke.")
     */
-    _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+    _signedFetch(prompt: string, options: this["ParsedCallOptions"], fields: {
+        bedrockMethod: "invoke" | "invoke-with-response-stream";
+        endpointHost: string;
+        provider: string;
+    }): Promise<Response>;
     _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
     _readChunks(reader: any): {
         [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;

package/dist/llms/bedrock.js

@@ -117,20 +117,23 @@ export class Bedrock extends LLM {
       Example:
         response = model.call("Tell me a joke.")
     */
-    async _call(prompt, options, runManager) {
-        const chunks = [];
-        for await (const chunk of this._streamResponseChunks(prompt, options, runManager)) {
-            chunks.push(chunk);
-        }
-        return chunks.map((chunk) => chunk.text).join("");
-    }
-    async *_streamResponseChunks(prompt, options, runManager) {
-        const provider = this.model.split(".")[0];
+    async _call(prompt, options) {
         const service = "bedrock-runtime";
-        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
         const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
-        const amazonMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
-        const url = new URL(`https://${endpointHost}/model/${this.model}/${amazonMethod}`);
+        const provider = this.model.split(".")[0];
+        const response = await this._signedFetch(prompt, options, {
+            bedrockMethod: "invoke",
+            endpointHost,
+            provider,
+        });
+        const json = await response.json();
+        const text = BedrockLLMInputOutputAdapter.prepareOutput(provider, json);
+        return text;
+    }
+    async _signedFetch(prompt, options, fields) {
+        const { bedrockMethod, endpointHost, provider } = fields;
+        const inputBody = BedrockLLMInputOutputAdapter.prepareInput(provider, prompt, this.maxTokens, this.temperature, this.stopSequences, this.modelKwargs);
+        const url = new URL(`https://${endpointHost}/model/${this.model}/${bedrockMethod}`);
         const request = new HttpRequest({
             hostname: url.hostname,
             path: url.pathname,
@@ -158,8 +161,21 @@ export class Bedrock extends LLM {
             body: signedRequest.body,
             method: signedRequest.method,
         }));
+        return response;
+    }
+    async *_streamResponseChunks(prompt, options, runManager) {
+        const provider = this.model.split(".")[0];
+        const bedrockMethod = provider === "anthropic" ? "invoke-with-response-stream" : "invoke";
+        const service = "bedrock-runtime";
+        const endpointHost = this.endpointHost ?? `${service}.${this.region}.amazonaws.com`;
+        // Send request to AWS using the low-level fetch API
+        const response = await this._signedFetch(prompt, options, {
+            bedrockMethod,
+            endpointHost,
+            provider,
+        });
         if (response.status < 200 || response.status >= 300) {
-            throw Error(`Failed to access underlying url '${url}': got ${response.status} ${response.statusText}: ${await response.text()}`);
+            throw Error(`Failed to access underlying url '${endpointHost}': got ${response.status} ${response.statusText}: ${await response.text()}`);
         }
         if (provider === "anthropic") {
             const reader = response.body?.getReader();

package/dist/load/import_constants.cjs

@@ -11,6 +11,7 @@ exports.optionalImportEntrypoints = [
     "langchain/tools/calculator",
     "langchain/tools/sql",
     "langchain/tools/webbrowser",
+    "langchain/tools/google_calendar",
     "langchain/chains/load",
     "langchain/chains/query_constructor",
     "langchain/chains/query_constructor/ir",

package/dist/load/import_constants.js

@@ -8,6 +8,7 @@ export const optionalImportEntrypoints = [
     "langchain/tools/calculator",
     "langchain/tools/sql",
     "langchain/tools/webbrowser",
+    "langchain/tools/google_calendar",
     "langchain/chains/load",
     "langchain/chains/query_constructor",
     "langchain/chains/query_constructor/ir",

package/dist/prompts/few_shot.d.ts

@@ -35,7 +35,7 @@ export interface FewShotPromptTemplateInput extends BasePromptTemplateInput<Inpu
      */
     suffix?: string;
     /**
-     * The format of the prompt template. Options are: 'f-string', 'jinja-2'
+     * The format of the prompt template. Options are: 'f-string'
      */
     templateFormat?: TemplateFormat;
     /**

package/dist/prompts/prompt.cjs

@@ -89,9 +89,6 @@ class PromptTemplate extends base_js_1.BaseStringPromptTemplate {
      * Load prompt template from a template f-string
      */
     static fromTemplate(template, { templateFormat = "f-string", ...rest } = {}) {
-        if (templateFormat === "jinja2") {
-            throw new Error("jinja2 templates are not currently supported.");
-        }
         const names = new Set();
         (0, template_js_1.parseTemplate)(template, templateFormat).forEach((node) => {
             if (node.type === "variable") {

package/dist/prompts/prompt.d.ts

@@ -12,7 +12,7 @@ export interface PromptTemplateInput<RunInput extends InputValues = any, Partial
      */
     template: string;
     /**
-     * The format of the prompt template. Options are 'f-string', 'jinja-2'
+     * The format of the prompt template. Options are 'f-string'
      *
      * @defaultValue 'f-string'
      */

package/dist/prompts/prompt.js

@@ -86,9 +86,6 @@ export class PromptTemplate extends BaseStringPromptTemplate {
      * Load prompt template from a template f-string
      */
     static fromTemplate(template, { templateFormat = "f-string", ...rest } = {}) {
-        if (templateFormat === "jinja2") {
-            throw new Error("jinja2 templates are not currently supported.");
-        }
         const names = new Set();
         parseTemplate(template, templateFormat).forEach((node) => {
             if (node.type === "variable") {

package/dist/prompts/template.cjs

@@ -62,11 +62,9 @@ const interpolateFString = (template, values) => (0, exports.parseFString)(templ
 exports.interpolateFString = interpolateFString;
 exports.DEFAULT_FORMATTER_MAPPING = {
     "f-string": exports.interpolateFString,
-    jinja2: (_, __) => "",
 };
 exports.DEFAULT_PARSER_MAPPING = {
     "f-string": exports.parseFString,
-    jinja2: (_) => [],
 };
 const renderTemplate = (template, templateFormat, inputValues) => exports.DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);
 exports.renderTemplate = renderTemplate;

package/dist/prompts/template.d.ts

@@ -1,9 +1,9 @@
 import { InputValues } from "../schema/index.js";
 /**
- * Type that specifies the format of a template. It can be either
- * "f-string" or "jinja2".
+ * Type that specifies the format of a template. Only
+ * "f-string" is supported currently.
  */
-export type TemplateFormat = "f-string" | "jinja2";
+export type TemplateFormat = "f-string";
 /**
  * Type that represents a node in a parsed format string. It can be either
  * a literal text or a variable name.

package/dist/prompts/template.js

@@ -57,11 +57,9 @@ export const interpolateFString = (template, values) => parseFString(template).r
 }, "");
 export const DEFAULT_FORMATTER_MAPPING = {
     "f-string": interpolateFString,
-    jinja2: (_, __) => "",
 };
 export const DEFAULT_PARSER_MAPPING = {
     "f-string": parseFString,
-    jinja2: (_) => [],
 };
 export const renderTemplate = (template, templateFormat, inputValues) => DEFAULT_FORMATTER_MAPPING[templateFormat](template, inputValues);
 export const parseTemplate = (template, templateFormat) => DEFAULT_PARSER_MAPPING[templateFormat](template);

package/dist/tools/google_calendar/base.cjs

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCalendarBase = void 0;
+const googleapis_1 = require("googleapis");
+const base_js_1 = require("../base.cjs");
+const env_js_1 = require("../../util/env.cjs");
+class GoogleCalendarBase extends base_js_1.Tool {
+    constructor(fields = {
+        credentials: {
+            clientEmail: (0, env_js_1.getEnvironmentVariable)("GOOGLE_CALENDAR_CLIENT_EMAIL"),
+            privateKey: (0, env_js_1.getEnvironmentVariable)("GOOGLE_CALENDAR_PRIVATE_KEY"),
+            calendarId: (0, env_js_1.getEnvironmentVariable)("GOOGLE_CALENDAR_CALENDAR_ID"),
+        },
+        scopes: [
+            "https://www.googleapis.com/auth/calendar",
+            "https://www.googleapis.com/auth/calendar.events",
+        ],
+    }) {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Google Calendar"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "A tool to lookup Google Calendar events and create events in Google Calendar"
+        });
+        Object.defineProperty(this, "clientEmail", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "privateKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "calendarId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.model) {
+            throw new Error("Missing llm instance to interact with Google Calendar");
+        }
+        if (!fields.credentials) {
+            throw new Error("Missing credentials to authenticate to Google Calendar");
+        }
+        if (!fields.credentials.clientEmail) {
+            throw new Error("Missing GOOGLE_CALENDAR_CLIENT_EMAIL to interact with Google Calendar");
+        }
+        if (!fields.credentials.privateKey) {
+            throw new Error("Missing GOOGLE_CALENDAR_PRIVATE_KEY to interact with Google Calendar");
+        }
+        if (!fields.credentials.calendarId) {
+            throw new Error("Missing GOOGLE_CALENDAR_CALENDAR_ID to interact with Google Calendar");
+        }
+        this.clientEmail = fields.credentials.clientEmail;
+        this.privateKey = fields.credentials.privateKey;
+        this.calendarId = fields.credentials.calendarId;
+        this.scopes = fields.scopes || [];
+        this.llm = fields.model;
+    }
+    getModel() {
+        return this.llm;
+    }
+    async getAuth() {
+        const auth = new googleapis_1.google.auth.JWT(this.clientEmail, undefined, this.privateKey, this.scopes);
+        return auth;
+    }
+    async _call(input) {
+        return input;
+    }
+}
+exports.GoogleCalendarBase = GoogleCalendarBase;

package/dist/tools/google_calendar/base.d.ts

@@ -0,0 +1,24 @@
+import { Tool } from "../base.js";
+import { BaseLLM } from "../../llms/base.js";
+export interface GoogleCalendarAgentParams {
+    credentials?: {
+        clientEmail?: string;
+        privateKey?: string;
+        calendarId?: string;
+    };
+    scopes?: string[];
+    model?: BaseLLM;
+}
+export declare class GoogleCalendarBase extends Tool {
+    name: string;
+    description: string;
+    protected clientEmail: string;
+    protected privateKey: string;
+    protected calendarId: string;
+    protected scopes: string[];
+    protected llm: BaseLLM;
+    constructor(fields?: GoogleCalendarAgentParams);
+    getModel(): BaseLLM<import("../../llms/base.js").BaseLLMCallOptions>;
+    getAuth(): Promise<import("googleapis-common").JWT>;
+    _call(input: string): Promise<string>;
+}

package/dist/tools/google_calendar/base.js

@@ -0,0 +1,90 @@
+import { google } from "googleapis";
+import { Tool } from "../base.js";
+import { getEnvironmentVariable } from "../../util/env.js";
+export class GoogleCalendarBase extends Tool {
+    constructor(fields = {
+        credentials: {
+            clientEmail: getEnvironmentVariable("GOOGLE_CALENDAR_CLIENT_EMAIL"),
+            privateKey: getEnvironmentVariable("GOOGLE_CALENDAR_PRIVATE_KEY"),
+            calendarId: getEnvironmentVariable("GOOGLE_CALENDAR_CALENDAR_ID"),
+        },
+        scopes: [
+            "https://www.googleapis.com/auth/calendar",
+            "https://www.googleapis.com/auth/calendar.events",
+        ],
+    }) {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Google Calendar"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "A tool to lookup Google Calendar events and create events in Google Calendar"
+        });
+        Object.defineProperty(this, "clientEmail", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "privateKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "calendarId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!fields.model) {
+            throw new Error("Missing llm instance to interact with Google Calendar");
+        }
+        if (!fields.credentials) {
+            throw new Error("Missing credentials to authenticate to Google Calendar");
+        }
+        if (!fields.credentials.clientEmail) {
+            throw new Error("Missing GOOGLE_CALENDAR_CLIENT_EMAIL to interact with Google Calendar");
+        }
+        if (!fields.credentials.privateKey) {
+            throw new Error("Missing GOOGLE_CALENDAR_PRIVATE_KEY to interact with Google Calendar");
+        }
+        if (!fields.credentials.calendarId) {
+            throw new Error("Missing GOOGLE_CALENDAR_CALENDAR_ID to interact with Google Calendar");
+        }
+        this.clientEmail = fields.credentials.clientEmail;
+        this.privateKey = fields.credentials.privateKey;
+        this.calendarId = fields.credentials.calendarId;
+        this.scopes = fields.scopes || [];
+        this.llm = fields.model;
+    }
+    getModel() {
+        return this.llm;
+    }
+    async getAuth() {
+        const auth = new google.auth.JWT(this.clientEmail, undefined, this.privateKey, this.scopes);
+        return auth;
+    }
+    async _call(input) {
+        return input;
+    }
+}

package/dist/tools/google_calendar/commands/run-create-events.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreateEvent = void 0;
+const googleapis_1 = require("googleapis");
+const index_js_1 = require("../../../prompts/index.cjs");
+const index_js_2 = require("../../../chains/index.cjs");
+const index_js_3 = require("../prompts/index.cjs");
+const get_timezone_offset_in_hours_js_1 = require("../utils/get-timezone-offset-in-hours.cjs");
+const createEvent = async ({ eventSummary, eventStartTime, eventEndTime, userTimezone, eventLocation = "", eventDescription = "", }, calendarId, auth) => {
+    const calendar = googleapis_1.google.calendar("v3");
+    const event = {
+        summary: eventSummary,
+        location: eventLocation,
+        description: eventDescription,
+        start: {
+            dateTime: eventStartTime,
+            timeZone: userTimezone,
+        },
+        end: {
+            dateTime: eventEndTime,
+            timeZone: userTimezone,
+        },
+    };
+    try {
+        const createdEvent = await calendar.events.insert({
+            auth,
+            calendarId,
+            requestBody: event,
+        });
+        return createdEvent;
+    }
+    catch (error) {
+        return {
+            error: `An error occurred: ${error}`,
+        };
+    }
+};
+const runCreateEvent = async (query, { calendarId, auth, model }, runManager) => {
+    const prompt = new index_js_1.PromptTemplate({
+        template: index_js_3.CREATE_EVENT_PROMPT,
+        inputVariables: ["date", "query", "u_timezone", "dayName"],
+    });
+    const createEventChain = new index_js_2.LLMChain({
+        llm: model,
+        prompt,
+    });
+    const date = new Date().toISOString();
+    const u_timezone = (0, get_timezone_offset_in_hours_js_1.getTimezoneOffsetInHours)();
+    const dayName = new Date().toLocaleString("en-us", { weekday: "long" });
+    const output = await createEventChain.call({
+        query,
+        date,
+        u_timezone,
+        dayName,
+    }, runManager?.getChild());
+    const loaded = JSON.parse(output.text);
+    const [eventSummary, eventStartTime, eventEndTime, eventLocation, eventDescription, userTimezone,] = Object.values(loaded);
+    const event = await createEvent({
+        eventSummary,
+        eventStartTime,
+        eventEndTime,
+        userTimezone,
+        eventLocation,
+        eventDescription,
+    }, calendarId, auth);
+    if (!event.error) {
+        return `Event created successfully, details: event ${event.data.htmlLink}`;
+    }
+    return `An error occurred creating the event: ${event.error}`;
+};
+exports.runCreateEvent = runCreateEvent;

package/dist/tools/google_calendar/commands/run-create-events.d.ts

@@ -0,0 +1,10 @@
+import type { JWT } from "googleapis-common";
+import { BaseLLM } from "../../../llms/base.js";
+import { CallbackManagerForToolRun } from "../../../callbacks/manager.js";
+type RunCreateEventParams = {
+    calendarId: string;
+    auth: JWT;
+    model: BaseLLM;
+};
+declare const runCreateEvent: (query: string, { calendarId, auth, model }: RunCreateEventParams, runManager?: CallbackManagerForToolRun) => Promise<string>;
+export { runCreateEvent };