@sierai/stargate/dist/index.js

Stargate Tools for AI Agents.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  default: () => index_default
});
module.exports = __toCommonJS(index_exports);

// src/auth/index.ts
var import_stargate_toolmaker3 = require("@sierai/stargate-toolmaker");

// src/auth/tools/get-auth-provider.ts
var import_stargate_toolmaker = require("@sierai/stargate-toolmaker");
var getAuthProviders = new import_stargate_toolmaker.StargateTool({
  name: "get_stargate_auth_providers",
  description: "This tool will get the list of available oauth providers",
  runner: async () => {
    return JSON.stringify([
      {
        id: "31eefcd7-278c-47ab-ab7b-fdc6603c3d76",
        name: "Slack",
        scopes: ["users:read", "chat:write", "channels:history"],
        description: "This provider will allow you to connect to slack"
      },
      {
        id: "95b82967-65bb-4e71-9129-20114a23150d",
        name: "Google",
        scopes: [
          "https://mail.google.com/",
          "https://www.googleapis.com/auth/documents",
          "https://www.googleapis.com/auth/drive",
          "https://www.googleapis.com/auth/calendar"
        ],
        description: "This provider will allow you to connect to Google"
      },
      {
        id: "ce2cd7ce-f104-4690-8991-13e55a3b2bd6",
        name: "GitHub",
        scopes: ["repo"],
        description: "This provider will allow you to connect to GitHub"
      },
      {
        id: "1b612fd5-a6bb-4a7d-96bb-15498ab8475e",
        name: "Zoom",
        scopes: ["meeting:write:meeting"],
        description: "This provider will allow you to connect to Zoom"
      }
    ]);
  }
});
var get_auth_provider_default = getAuthProviders;

// src/auth/tools/get-auth-server-url.ts
var import_zod = require("zod");
var import_stargate_toolmaker2 = require("@sierai/stargate-toolmaker");
var import_stargate_logger = require("@sierai/stargate-logger");
var getAuthServerUrl = new import_stargate_toolmaker2.StargateTool({
  name: "get_auth_server_url",
  description: `This tool will start the OAuth flow for the given provider and scope by returning the authorization server URL, get oauth providers by using the tool 'oauth_providers',
  Example: Please click on the link below to give permissions: [Provider Name](Server URL).`,
  schema: import_zod.z.object({
    providerId: import_zod.z.string().describe("Provider ID from the OAuth Providers list"),
    provider: import_zod.z.string().describe("Provider name"),
    scopes: import_zod.z.array(import_zod.z.string()).describe("Scopes to request from the provider")
  }),
  runner: async (input, config) => {
    import_stargate_logger.logger.info({
      message: "get_oauth_server_url inputs",
      input
    });
    const queryString = (await import("query-string")).default;
    const { providerId, scopes } = input;
    const scopeString = queryString.stringify(
      { scopes },
      { arrayFormat: "comma" }
    );
    const url = queryString.stringifyUrl({
      url: `${process.env.STARGATE_ENDPOINT}/oauth?${scopeString}`,
      query: {
        sessionId: config.configurable?.sessionId,
        providerId
      }
    });
    return url;
  }
});
var get_auth_server_url_default = getAuthServerUrl;

// src/auth/index.ts
var authProvider = new import_stargate_toolmaker3.StargateProvider({
  type: import_stargate_toolmaker3.StargateProvider.Type.Extension,
  name: "Stargate Connection",
  description: "This tool provider will allow you to connect to many services using OAuth"
});
authProvider.addTool(get_auth_provider_default);
authProvider.addTool(get_auth_server_url_default);
var auth_default = authProvider;

// src/providers/github/index.ts
var import_stargate_auth = require("@sierai/stargate-auth");
var import_stargate_toolmaker5 = require("@sierai/stargate-toolmaker");

// src/providers/github/tools/createNewRepo.ts
var import_zod2 = require("zod");
var import_stargate_toolmaker4 = require("@sierai/stargate-toolmaker");
var createNewRepo = new import_stargate_toolmaker4.StargateTool({
  name: "create_repo",
  description: "This tool will create a new repository in the github account",
  schema: import_zod2.z.object({
    name: import_zod2.z.string().describe("Name of the repository to create")
  }),
  runner: async (input, config, oauthProvider) => {
    const res = await oauthProvider.createNewRepo({ name: input.name });
    return JSON.stringify(res);
  }
});
var createNewRepo_default = createNewRepo;

// src/providers/github/index.ts
var github = new import_stargate_toolmaker5.StargateProvider({
  name: "GitHub",
  description: "This tool provider is from GitHub",
  type: import_stargate_toolmaker5.StargateProvider.Type.Connection,
  oauthProvider: new import_stargate_auth.GitHub()
});
github.addTool(createNewRepo_default);
var github_default = github;

// src/providers/gmail/index.ts
var import_stargate_toolmaker7 = require("@sierai/stargate-toolmaker");

// src/providers/gmail/tools/send-email.ts
var import_zod3 = require("zod");
var import_stargate_toolmaker6 = require("@sierai/stargate-toolmaker");
var sendGmail = new import_stargate_toolmaker6.StargateTool({
  name: "send_gmail",
  description: "This tool will send an email using Gmail. Ask user to connect if it's unauthed. You can use this tool directly, start by asking the recipient for their email address.",
  schema: import_zod3.z.object({
    title: import_zod3.z.string().describe("Title of the document."),
    body: import_zod3.z.string().describe("Body of the document in plain text."),
    recipient: import_zod3.z.string().describe("Recipient of the email.")
  }),
  runner: async (input, config, oauthProvider) => {
    try {
      return await oauthProvider.sendEmail({
        title: input.title,
        body: input.body,
        recipient: input.recipient
      });
    } catch (err) {
      return "Error fetching events: " + err;
    }
  }
});
var send_email_default = sendGmail;

// src/providers/gmail/index.ts
var import_stargate_auth2 = require("@sierai/stargate-auth");
var gmailProvider = new import_stargate_toolmaker7.StargateProvider({
  type: import_stargate_toolmaker7.StargateProvider.Type.Connection,
  name: "Gmail",
  description: "This is Gmail tool provider",
  oauthProvider: new import_stargate_auth2.Google()
});
gmailProvider.addTool(send_email_default);
var gmail_default = gmailProvider;

// src/providers/google-calendar/index.ts
var import_stargate_toolmaker9 = require("@sierai/stargate-toolmaker");

// src/providers/google-calendar/tools/list-events.ts
var import_zod4 = require("zod");
var import_stargate_toolmaker8 = require("@sierai/stargate-toolmaker");
var import_stargate_logger2 = require("@sierai/stargate-logger");
var listEvents = new import_stargate_toolmaker8.StargateTool({
  name: "list_google_calendar_events",
  description: "This tool will list the upcoming events from the user's Google Calendar.",
  schema: import_zod4.z.object({
    noOp: import_zod4.z.string().optional().describe("No-op parameter.")
  }),
  runner: async (_, config, oauthProvider) => {
    try {
      import_stargate_logger2.logger.info({
        message: "Auth check wrapper: Authed",
        provider: oauthProvider.isAuthed
      });
      return await oauthProvider.listEvents();
    } catch (err) {
      return "Error fetching events: " + err;
    }
  }
});
var list_events_default = listEvents;

// src/providers/google-calendar/index.ts
var import_stargate_auth3 = require("@sierai/stargate-auth");
var googleCalendar = new import_stargate_toolmaker9.StargateProvider({
  name: "Google Calendar",
  description: "This tool provider will provide tools to interact with Google Calendar.",
  type: import_stargate_toolmaker9.StargateProvider.Type.Connection,
  oauthProvider: new import_stargate_auth3.Google()
});
googleCalendar.addTool(list_events_default);
var google_calendar_default = googleCalendar;

// src/providers/google-docs/index.ts
var import_stargate_toolmaker11 = require("@sierai/stargate-toolmaker");

// src/providers/google-docs/tools/create-docs.ts
var import_zod5 = require("zod");
var import_stargate_toolmaker10 = require("@sierai/stargate-toolmaker");
var createGoogleDocs = new import_stargate_toolmaker10.StargateTool({
  name: "create_google_docs",
  description: "This tool will create a new Google Docs document. It requires the title and body of the document. After creating the document, it will return the document ID, give user the full url to the document.",
  schema: import_zod5.z.object({
    title: import_zod5.z.string().describe("Title of the document."),
    body: import_zod5.z.string().describe("Body of the document.")
  }),
  runner: async (input, config, oauthProvider) => {
    try {
      return await oauthProvider.createNewDocument({
        title: input.title,
        body: input.body
      });
      return "Not authenticated.";
    } catch (err) {
      return "Error fetching events: " + err;
    }
  }
});
var create_docs_default = createGoogleDocs;

// src/providers/google-docs/index.ts
var import_stargate_auth4 = require("@sierai/stargate-auth");
var googleDocs = new import_stargate_toolmaker11.StargateProvider({
  type: import_stargate_toolmaker11.StargateProvider.Type.Connection,
  name: "Google Docs",
  description: "This tool provider will provide tools to connect to Google services.",
  logoUrl: "https://lh3.googleusercontent.com/1DECuhPQ1y2ppuL6tdEqNSuObIm_PW64w0mNhm3KGafi40acOJkc4nvsZnThoDKTH8gWyxAnipJmvCiszX8R6UAUu1UyXPfF13d7",
  oauthProvider: new import_stargate_auth4.Google()
});
googleDocs.addTools([create_docs_default]);
var google_docs_default = googleDocs;

// src/providers/slack/index.ts
var import_stargate_toolmaker15 = require("@sierai/stargate-toolmaker");

// src/providers/slack/tools/getChannelMessages.ts
var import_zod6 = require("zod");
var import_stargate_logger3 = require("@sierai/stargate-logger");
var import_stargate_toolmaker12 = require("@sierai/stargate-toolmaker");
var getChannelMessages = new import_stargate_toolmaker12.StargateTool({
  name: "get_channel_messages",
  description: "This tool will get the messages from a slack channel, assist the user based on the messages.",
  schema: import_zod6.z.object({}),
  runner: async (_, config, oauthProvider) => {
    const messages = await oauthProvider.getChannelMessages();
    import_stargate_logger3.logger.info({
      message: "Messages fetched",
      messages
    });
    return JSON.stringify(messages);
  }
});
var getChannelMessages_default = getChannelMessages;

// src/providers/slack/tools/sendMessage.ts
var import_zod7 = require("zod");
var import_stargate_toolmaker13 = require("@sierai/stargate-toolmaker");
var sendMessage = new import_stargate_toolmaker13.StargateTool({
  name: "slack_send_message",
  description: "This tool will send a message to a slack channel",
  schema: import_zod7.z.object({
    message: import_zod7.z.string().describe("Message to send to the channel")
  }),
  runner: async (input, config, oauthProvider) => {
    const res = await oauthProvider.sendMessage({ text: input.message });
    return res;
  }
});
var sendMessage_default = sendMessage;

// src/providers/slack/tools/getUsers.ts
var import_stargate_toolmaker14 = require("@sierai/stargate-toolmaker");
var getUsers = new import_stargate_toolmaker14.StargateTool({
  name: "slack_get_users",
  description: "This tool will get the users from a slack workspace",
  runner: async (_, config, oauthProvider) => {
    const res = await oauthProvider.getUsers();
    return JSON.stringify(res);
  }
});
var getUsers_default = getUsers;

// src/providers/slack/index.ts
var import_stargate_auth5 = require("@sierai/stargate-auth");
var slack = new import_stargate_toolmaker15.StargateProvider({
  type: import_stargate_toolmaker15.StargateProvider.Type.Connection,
  name: "Slack",
  description: "This tool provider will allow you to connect to slack and perform actions",
  oauthProvider: new import_stargate_auth5.Slack()
});
slack.addTool(getChannelMessages_default);
slack.addTool(sendMessage_default);
slack.addTool(getUsers_default);
var slack_default = slack;

// src/providers/zoom/index.ts
var import_stargate_auth6 = require("@sierai/stargate-auth");
var import_stargate_toolmaker17 = require("@sierai/stargate-toolmaker");

// src/providers/zoom/tools/createMeeting.ts
var import_stargate_toolmaker16 = require("@sierai/stargate-toolmaker");
var import_zod8 = require("zod");
var import_stargate_logger4 = require("@sierai/stargate-logger");
var createMeeting = new import_stargate_toolmaker16.StargateTool({
  name: "create_meeting",
  description: "This tool will create a meeting on zoom, use OAuth to connect to zoom if the user is not connected",
  schema: import_zod8.z.object({
    // topic: z.string().describe("The topic of the meeting"),
    // start_time: z.string().describe("The start time of the meeting"),
    // duration: z.string().describe("The duration of the meeting"),
    noOp: import_zod8.z.string().optional().describe("No operation")
  }),
  runner: async (input, config, oauthProvider) => {
    try {
      return await oauthProvider.createMeeting();
    } catch (error) {
      import_stargate_logger4.logger.error({ message: error });
      return error;
    }
  }
});
var createMeeting_default = createMeeting;

// src/providers/zoom/index.ts
var zoom = new import_stargate_toolmaker17.StargateProvider({
  name: "Zoom",
  description: "This tool provider is from Zoom",
  type: import_stargate_toolmaker17.StargateProvider.Type.Connection,
  oauthProvider: new import_stargate_auth6.Zoom()
});
zoom.addTool(createMeeting_default);
var zoom_default = zoom;

// src/providers/sier/index.ts
var import_stargate_toolmaker21 = require("@sierai/stargate-toolmaker");

// src/providers/sier/tools/getTheNumber.ts
var import_zod9 = require("zod");
var import_stargate_toolmaker18 = require("@sierai/stargate-toolmaker");

// package.json
var package_default = {
  name: "@sierai/stargate",
  version: "0.0.8",
  description: "Stargate Tools for AI Agents.",
  scripts: {
    build: "tsup src/index.ts --format cjs,esm --dts"
  },
  main: "./dist/index.js",
  module: "./dist/index.mjs",
  types: "./dist/index.d.ts",
  keywords: [
    "AI Tools",
    "AI Agents",
    "LLM Tools",
    "Langchain"
  ],
  author: "SIER",
  license: "MIT",
  dependencies: {
    "@sierai/stargate-logger": "workspace:*",
    "@sierai/stargate-auth": "workspace:*",
    "@sierai/stargate-toolmaker": "workspace:*",
    "query-string": "^9.1.1",
    typescript: "^5.7.3",
    zod: "^3.24.1"
  },
  devDependencies: {
    tsup: "^8.3.5",
    "@tsconfig/node-lts": "^22.0.1"
  }
};

// src/providers/sier/tools/getTheNumber.ts
var getTheNumber = new import_stargate_toolmaker18.StargateTool({
  name: "getTheNumber",
  description: "This tool will get the number",
  schema: import_zod9.z.object({
    noOp: import_zod9.z.string().optional().describe("No-op parameter.")
  }),
  runner: async () => `42 | Stargate verion: ${package_default.version}`
});
var getTheNumber_default = getTheNumber;

// src/providers/sier/tools/getToolSchema.ts
var import_zod10 = require("zod");
var import_stargate_toolmaker19 = require("@sierai/stargate-toolmaker");
var getProviderToolSchemas = new import_stargate_toolmaker19.StargateTool({
  name: "getProviderToolSchema",
  description: "This tool will get the tool schemas available for a specific provider",
  schema: import_zod10.z.object({
    provider: import_zod10.z.string().describe("Name of the provider to get the schema for")
  }),
  runner: async (input, config, oauthProvider) => {
    return JSON.stringify({
      name: "gmail_schemas",
      description: "Tool schemas using Gmail API",
      schemas: [
        {
          name: "send_email",
          description: "Send an email to a given recipient with a subject and message.",
          parameters: {
            type: "object",
            properties: {
              to: {
                type: "string",
                description: "The recipient email address."
              },
              subject: {
                type: "string",
                description: "Email subject line."
              },
              body: {
                type: "string",
                description: "Body of the email message."
              }
            },
            required: ["to", "subject", "body"],
            additionalProperties: false
          }
        }
      ]
    });
  }
});
var getToolSchema_default = getProviderToolSchemas;

// src/providers/sier/tools/executeTool.ts
var import_zod11 = require("zod");
var import_stargate_toolmaker20 = require("@sierai/stargate-toolmaker");
var executeTool = new import_stargate_toolmaker20.StargateTool({
  name: "executeTool",
  description: "This tool will execute the tool based on the tool schema from the getProviderToolSchemas tool",
  schema: import_zod11.z.object({
    provider: import_zod11.z.string().describe("Name of the provider to execute the tool for"),
    method: import_zod11.z.string().describe("Name of the method to execute"),
    parameters: import_zod11.z.unknown().describe("Parameters to execute the method")
  }),
  runner: async (input, config, oauthProvider) => {
    return JSON.stringify(input);
  }
});
var executeTool_default = executeTool;

// src/providers/sier/index.ts
var sier = new import_stargate_toolmaker21.StargateProvider({
  type: import_stargate_toolmaker21.StargateProvider.Type.Extension,
  name: "SIER",
  description: "This tool provider is from SIER"
});
sier.addTool(getTheNumber_default);
sier.addTool(getToolSchema_default);
sier.addTool(executeTool_default);
var sier_default = sier;

// src/providers/index.ts
var providers_default = { github: github_default, gmail: gmail_default, googleCalendar: google_calendar_default, googleDocs: google_docs_default, slack: slack_default, zoom: zoom_default, sier: sier_default };

// src/stargate.ts
var Stargate = class {
  apiKey;
  providers;
  constructor(options) {
    this.apiKey = options.apiKey;
    this.providers = options.providers;
  }
  get tools() {
    return auth_default.install().concat(
      this.providers.map((provider) => {
        return providers_default[provider].install();
      }).flat()
    );
  }
};
var stargate_default = Stargate;

// src/index.ts
var index_default = stargate_default;