@sierai/stargate/dist/index.mjs

Stargate Tools for AI Agents.

// src/auth/index.ts
import { StargateProvider } from "@sierai/stargate-toolmaker";

// src/auth/tools/get-auth-provider.ts
import { StargateTool } from "@sierai/stargate-toolmaker";
var getAuthProviders = new 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
import { z } from "zod";
import { StargateTool as StargateTool2 } from "@sierai/stargate-toolmaker";
import { logger } from "@sierai/stargate-logger";
var getAuthServerUrl = new StargateTool2({
  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: z.object({
    providerId: z.string().describe("Provider ID from the OAuth Providers list"),
    provider: z.string().describe("Provider name"),
    scopes: z.array(z.string()).describe("Scopes to request from the provider")
  }),
  runner: async (input, config) => {
    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 StargateProvider({
  type: 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
import { GitHub } from "@sierai/stargate-auth";
import { StargateProvider as StargateProvider2 } from "@sierai/stargate-toolmaker";

// src/providers/github/tools/createNewRepo.ts
import { z as z2 } from "zod";
import { StargateTool as StargateTool3 } from "@sierai/stargate-toolmaker";
var createNewRepo = new StargateTool3({
  name: "create_repo",
  description: "This tool will create a new repository in the github account",
  schema: z2.object({
    name: z2.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 StargateProvider2({
  name: "GitHub",
  description: "This tool provider is from GitHub",
  type: StargateProvider2.Type.Connection,
  oauthProvider: new GitHub()
});
github.addTool(createNewRepo_default);
var github_default = github;

// src/providers/gmail/index.ts
import { StargateProvider as StargateProvider3 } from "@sierai/stargate-toolmaker";

// src/providers/gmail/tools/send-email.ts
import { z as z3 } from "zod";
import { StargateTool as StargateTool4 } from "@sierai/stargate-toolmaker";
var sendGmail = new StargateTool4({
  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: z3.object({
    title: z3.string().describe("Title of the document."),
    body: z3.string().describe("Body of the document in plain text."),
    recipient: z3.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
import { Google } from "@sierai/stargate-auth";
var gmailProvider = new StargateProvider3({
  type: StargateProvider3.Type.Connection,
  name: "Gmail",
  description: "This is Gmail tool provider",
  oauthProvider: new Google()
});
gmailProvider.addTool(send_email_default);
var gmail_default = gmailProvider;

// src/providers/google-calendar/index.ts
import { StargateProvider as StargateProvider4 } from "@sierai/stargate-toolmaker";

// src/providers/google-calendar/tools/list-events.ts
import { z as z4 } from "zod";
import { StargateTool as StargateTool5 } from "@sierai/stargate-toolmaker";
import { logger as logger2 } from "@sierai/stargate-logger";
var listEvents = new StargateTool5({
  name: "list_google_calendar_events",
  description: "This tool will list the upcoming events from the user's Google Calendar.",
  schema: z4.object({
    noOp: z4.string().optional().describe("No-op parameter.")
  }),
  runner: async (_, config, oauthProvider) => {
    try {
      logger2.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
import { Google as Google2 } from "@sierai/stargate-auth";
var googleCalendar = new StargateProvider4({
  name: "Google Calendar",
  description: "This tool provider will provide tools to interact with Google Calendar.",
  type: StargateProvider4.Type.Connection,
  oauthProvider: new Google2()
});
googleCalendar.addTool(list_events_default);
var google_calendar_default = googleCalendar;

// src/providers/google-docs/index.ts
import { StargateProvider as StargateProvider5 } from "@sierai/stargate-toolmaker";

// src/providers/google-docs/tools/create-docs.ts
import { z as z5 } from "zod";
import { StargateTool as StargateTool6 } from "@sierai/stargate-toolmaker";
var createGoogleDocs = new StargateTool6({
  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: z5.object({
    title: z5.string().describe("Title of the document."),
    body: z5.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
import { Google as Google3 } from "@sierai/stargate-auth";
var googleDocs = new StargateProvider5({
  type: StargateProvider5.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 Google3()
});
googleDocs.addTools([create_docs_default]);
var google_docs_default = googleDocs;

// src/providers/slack/index.ts
import { StargateProvider as StargateProvider6 } from "@sierai/stargate-toolmaker";

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

// src/providers/slack/tools/sendMessage.ts
import { z as z7 } from "zod";
import { StargateTool as StargateTool8 } from "@sierai/stargate-toolmaker";
var sendMessage = new StargateTool8({
  name: "slack_send_message",
  description: "This tool will send a message to a slack channel",
  schema: z7.object({
    message: z7.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
import { StargateTool as StargateTool9 } from "@sierai/stargate-toolmaker";
var getUsers = new StargateTool9({
  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
import { Slack } from "@sierai/stargate-auth";
var slack = new StargateProvider6({
  type: StargateProvider6.Type.Connection,
  name: "Slack",
  description: "This tool provider will allow you to connect to slack and perform actions",
  oauthProvider: new Slack()
});
slack.addTool(getChannelMessages_default);
slack.addTool(sendMessage_default);
slack.addTool(getUsers_default);
var slack_default = slack;

// src/providers/zoom/index.ts
import { Zoom } from "@sierai/stargate-auth";
import { StargateProvider as StargateProvider7 } from "@sierai/stargate-toolmaker";

// src/providers/zoom/tools/createMeeting.ts
import { StargateTool as StargateTool10 } from "@sierai/stargate-toolmaker";
import { z as z8 } from "zod";
import { logger as logger4 } from "@sierai/stargate-logger";
var createMeeting = new StargateTool10({
  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: z8.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: z8.string().optional().describe("No operation")
  }),
  runner: async (input, config, oauthProvider) => {
    try {
      return await oauthProvider.createMeeting();
    } catch (error) {
      logger4.error({ message: error });
      return error;
    }
  }
});
var createMeeting_default = createMeeting;

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

// src/providers/sier/index.ts
import { StargateProvider as StargateProvider8 } from "@sierai/stargate-toolmaker";

// src/providers/sier/tools/getTheNumber.ts
import { z as z9 } from "zod";
import { StargateTool as StargateTool11 } from "@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 StargateTool11({
  name: "getTheNumber",
  description: "This tool will get the number",
  schema: z9.object({
    noOp: z9.string().optional().describe("No-op parameter.")
  }),
  runner: async () => `42 | Stargate verion: ${package_default.version}`
});
var getTheNumber_default = getTheNumber;

// src/providers/sier/tools/getToolSchema.ts
import { z as z10 } from "zod";
import { StargateTool as StargateTool12 } from "@sierai/stargate-toolmaker";
var getProviderToolSchemas = new StargateTool12({
  name: "getProviderToolSchema",
  description: "This tool will get the tool schemas available for a specific provider",
  schema: z10.object({
    provider: z10.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
import { z as z11 } from "zod";
import { StargateTool as StargateTool13 } from "@sierai/stargate-toolmaker";
var executeTool = new StargateTool13({
  name: "executeTool",
  description: "This tool will execute the tool based on the tool schema from the getProviderToolSchemas tool",
  schema: z11.object({
    provider: z11.string().describe("Name of the provider to execute the tool for"),
    method: z11.string().describe("Name of the method to execute"),
    parameters: z11.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 StargateProvider8({
  type: StargateProvider8.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;
export {
  index_default as default
};