added image2 command

commands/fun/image.js

@@ -17,7 +17,7 @@ module.exports = {
             const response = await openai.createImage({
                 prompt: `${message.content.slice(7, message.content.length)}`,
                 n: 1,
-                size: "1024x1024",
+                size: "512x512",
               });
               image_url = response.data.data[0].url;
               error = response

commands/fun/image2.js

@@ -0,0 +1,115 @@
+const { Configuration, OpenAIApi } = require("openai");
+const { grpc } = require("@improbable-eng/grpc-web")
+const {NodeHttpTransport } = require("@improbable-eng/grpc-web-node-http-transport")
+grpc.setDefaultTransport(NodeHttpTransport());
+
+const GenerationService = require("../../generation/generation_pb_service")
+const Generation = require("../../generation/generation_pb")
+
+
+
+const configuration = new Configuration({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+const openai = new OpenAIApi(configuration);
+
+
+
+module.exports = {
+	name: 'image2',
+	description: 'AI image generation',
+	async execute(message, args){
+      const imageParams = new Generation.ImageParameters();
+      imageParams.setWidth(512);
+      imageParams.setHeight(512);
+      imageParams.addSeed(11223344);
+      imageParams.setSamples(1);
+      imageParams.setSteps(75);
+
+      // Use the `k-dpmpp-2` sampler
+      const transformType = new Generation.TransformType();
+      transformType.setDiffusion(Generation.DiffusionSampler.SAMPLER_K_DPMPP_2M);
+      imageParams.setTransform(transformType);
+
+      // Use Stable Diffusion 2.0
+      const request = new Generation.Request();
+      request.setEngineId("stable-diffusion-512-v2-1");
+      request.setRequestedType(Generation.ArtifactType.ARTIFACT_IMAGE);
+      request.setClassifier(new Generation.ClassifierParameters());
+
+      // Use a CFG scale of `13`
+      const samplerParams = new Generation.SamplerParameters();
+      samplerParams.setCfgScale(13);
+
+      const stepParams = new Generation.StepParameter();
+      const scheduleParameters = new Generation.ScheduleParameters();
+
+      // Set the schedule to `0`, this changes when doing an initial image generation
+      stepParams.setScaledStep(0);
+      stepParams.setSampler(samplerParams);
+      stepParams.setSchedule(scheduleParameters);
+
+      imageParams.addParameters(stepParams);
+      request.setImage(imageParams);
+
+      // Set our text prompt
+      const promptText = new Generation.Prompt();
+      promptText.setText(
+        `${message.content.slice(7, message.content.length)}`
+      );
+
+      request.addPrompt(promptText);
+
+      // Authenticate using your API key, don't commit your key to a public repository!
+      const metadata = new grpc.Metadata();
+      metadata.set("Authorization", "Bearer " + process.env.API_KEY);
+
+      // Create a generation client
+      const generationClient = new GenerationService.GenerationServiceClient(
+        "https://grpc.stability.ai",
+        {}
+      );
+
+      // Send the request using the `metadata` with our key from earlier
+      const generation = generationClient.generate(request, metadata);
+
+      // Set up a callback to handle data being returned
+      generation.on("data", (data) => {
+        data.getArtifactsList().forEach((artifact) => {
+          // Oh no! We were filtered by the NSFW classifier!
+          if (
+            artifact.getType() === Generation.ArtifactType.ARTIFACT_TEXT &&
+            artifact.getFinishReason() === Generation.FinishReason.FILTER
+          ) {
+            return console.error("Your image was filtered by the NSFW classifier.");
+          }
+
+          // Make sure we have an image
+          if (artifact.getType() !== Generation.ArtifactType.ARTIFACT_IMAGE) return;
+
+          // You can convert the raw binary into a base64 string
+          const base64Image = btoa(
+            new Uint8Array(artifact.getBinary()).reduce(
+              (data, byte) => data + String.fromCodePoint(byte),
+              ""
+            )
+          );
+
+          // Here's how you get the seed back if you set it to `0` (random)
+          const seed = artifact.getSeed();
+
+          // We're done!
+          sfbuffer = new Buffer.from(base64Image, "base64");
+          message.reply({files: [{ attachment: sfbuffer, name: 'newName.png' }]})
+        });
+      });
+
+      // Anything other than `status.code === 0` is an error
+      generation.on("status", (status) => {
+        if (status.code === 0) return;
+        console.error(
+          "Your image could not be generated. You might not have enough credits."
+        );
+      });
+	},
+};

generation/generation_grpc_pb.d.ts

@@ -0,0 +1,27 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: gooseai
+// file: generation.proto
+
+import * as generation_pb from "./generation_pb";
+import * as grpc from "grpc";
+
+interface IGenerationServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  generate: grpc.MethodDefinition<generation_pb.Request, generation_pb.Answer>;
+  chainGenerate: grpc.MethodDefinition<generation_pb.ChainRequest, generation_pb.Answer>;
+}
+
+export const GenerationServiceService: IGenerationServiceService;
+
+export interface IGenerationServiceServer extends grpc.UntypedServiceImplementation {
+  generate: grpc.handleServerStreamingCall<generation_pb.Request, generation_pb.Answer>;
+  chainGenerate: grpc.handleServerStreamingCall<generation_pb.ChainRequest, generation_pb.Answer>;
+}
+
+export class GenerationServiceClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  generate(argument: generation_pb.Request, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<generation_pb.Answer>;
+  generate(argument: generation_pb.Request, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<generation_pb.Answer>;
+  chainGenerate(argument: generation_pb.ChainRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<generation_pb.Answer>;
+  chainGenerate(argument: generation_pb.ChainRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<generation_pb.Answer>;
+}

generation/generation_grpc_pb.js

@@ -0,0 +1,71 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('grpc');
+var generation_pb = require('./generation_pb.js');
+var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
+var tensors_pb = require('./tensors_pb.js');
+
+function serialize_gooseai_Answer(arg) {
+  if (!(arg instanceof generation_pb.Answer)) {
+    throw new Error('Expected argument of type gooseai.Answer');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gooseai_Answer(buffer_arg) {
+  return generation_pb.Answer.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gooseai_ChainRequest(arg) {
+  if (!(arg instanceof generation_pb.ChainRequest)) {
+    throw new Error('Expected argument of type gooseai.ChainRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gooseai_ChainRequest(buffer_arg) {
+  return generation_pb.ChainRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gooseai_Request(arg) {
+  if (!(arg instanceof generation_pb.Request)) {
+    throw new Error('Expected argument of type gooseai.Request');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gooseai_Request(buffer_arg) {
+  return generation_pb.Request.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+//
+// gRPC services
+//
+var GenerationServiceService = exports.GenerationServiceService = {
+  generate: {
+    path: '/gooseai.GenerationService/Generate',
+    requestStream: false,
+    responseStream: true,
+    requestType: generation_pb.Request,
+    responseType: generation_pb.Answer,
+    requestSerialize: serialize_gooseai_Request,
+    requestDeserialize: deserialize_gooseai_Request,
+    responseSerialize: serialize_gooseai_Answer,
+    responseDeserialize: deserialize_gooseai_Answer,
+  },
+  chainGenerate: {
+    path: '/gooseai.GenerationService/ChainGenerate',
+    requestStream: false,
+    responseStream: true,
+    requestType: generation_pb.ChainRequest,
+    responseType: generation_pb.Answer,
+    requestSerialize: serialize_gooseai_ChainRequest,
+    requestDeserialize: deserialize_gooseai_ChainRequest,
+    responseSerialize: serialize_gooseai_Answer,
+    responseDeserialize: deserialize_gooseai_Answer,
+  },
+};
+
+exports.GenerationServiceClient = grpc.makeGenericClientConstructor(GenerationServiceService);

generation/generation_pb_service.d.ts

@@ -0,0 +1,66 @@
+// package: gooseai
+// file: generation.proto
+
+import * as generation_pb from "./generation_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type GenerationServiceGenerate = {
+  readonly methodName: string;
+  readonly service: typeof GenerationService;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof generation_pb.Request;
+  readonly responseType: typeof generation_pb.Answer;
+};
+
+type GenerationServiceChainGenerate = {
+  readonly methodName: string;
+  readonly service: typeof GenerationService;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof generation_pb.ChainRequest;
+  readonly responseType: typeof generation_pb.Answer;
+};
+
+export class GenerationService {
+  static readonly serviceName: string;
+  static readonly Generate: GenerationServiceGenerate;
+  static readonly ChainGenerate: GenerationServiceChainGenerate;
+}
+
+export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
+export type Status = { details: string, code: number; metadata: grpc.Metadata }
+
+interface UnaryResponse {
+  cancel(): void;
+}
+interface ResponseStream<T> {
+  cancel(): void;
+  on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
+  on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
+  on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
+}
+interface RequestStream<T> {
+  write(message: T): RequestStream<T>;
+  end(): void;
+  cancel(): void;
+  on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
+  on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
+}
+interface BidirectionalStream<ReqT, ResT> {
+  write(message: ReqT): BidirectionalStream<ReqT, ResT>;
+  end(): void;
+  cancel(): void;
+  on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
+}
+
+export class GenerationServiceClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  generate(requestMessage: generation_pb.Request, metadata?: grpc.Metadata): ResponseStream<generation_pb.Answer>;
+  chainGenerate(requestMessage: generation_pb.ChainRequest, metadata?: grpc.Metadata): ResponseStream<generation_pb.Answer>;
+}
+

generation/generation_pb_service.js

@@ -0,0 +1,117 @@
+// package: gooseai
+// file: generation.proto
+
+var generation_pb = require("./generation_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var GenerationService = (function () {
+  function GenerationService() {}
+  GenerationService.serviceName = "gooseai.GenerationService";
+  return GenerationService;
+}());
+
+GenerationService.Generate = {
+  methodName: "Generate",
+  service: GenerationService,
+  requestStream: false,
+  responseStream: true,
+  requestType: generation_pb.Request,
+  responseType: generation_pb.Answer
+};
+
+GenerationService.ChainGenerate = {
+  methodName: "ChainGenerate",
+  service: GenerationService,
+  requestStream: false,
+  responseStream: true,
+  requestType: generation_pb.ChainRequest,
+  responseType: generation_pb.Answer
+};
+
+exports.GenerationService = GenerationService;
+
+function GenerationServiceClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+GenerationServiceClient.prototype.generate = function generate(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(GenerationService.Generate, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+GenerationServiceClient.prototype.chainGenerate = function chainGenerate(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(GenerationService.ChainGenerate, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+exports.GenerationServiceClient = GenerationServiceClient;
+

generation/tensors_pb.d.ts

@@ -0,0 +1,172 @@
+// package: tensors
+// file: tensors.proto
+
+import * as jspb from "google-protobuf";
+
+export class Tensor extends jspb.Message {
+  getDtype(): DtypeMap[keyof DtypeMap];
+  setDtype(value: DtypeMap[keyof DtypeMap]): void;
+
+  clearShapeList(): void;
+  getShapeList(): Array<number>;
+  setShapeList(value: Array<number>): void;
+  addShape(value: number, index?: number): number;
+
+  getData(): Uint8Array | string;
+  getData_asU8(): Uint8Array;
+  getData_asB64(): string;
+  setData(value: Uint8Array | string): void;
+
+  hasAttrType(): boolean;
+  clearAttrType(): void;
+  getAttrType(): AttributeTypeMap[keyof AttributeTypeMap];
+  setAttrType(value: AttributeTypeMap[keyof AttributeTypeMap]): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Tensor.AsObject;
+  static toObject(includeInstance: boolean, msg: Tensor): Tensor.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Tensor, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Tensor;
+  static deserializeBinaryFromReader(message: Tensor, reader: jspb.BinaryReader): Tensor;
+}
+
+export namespace Tensor {
+  export type AsObject = {
+    dtype: DtypeMap[keyof DtypeMap],
+    shapeList: Array<number>,
+    data: Uint8Array | string,
+    attrType: AttributeTypeMap[keyof AttributeTypeMap],
+  }
+}
+
+export class Attribute extends jspb.Message {
+  getName(): string;
+  setName(value: string): void;
+
+  hasModule(): boolean;
+  clearModule(): void;
+  getModule(): Module | undefined;
+  setModule(value?: Module): void;
+
+  hasTensor(): boolean;
+  clearTensor(): void;
+  getTensor(): Tensor | undefined;
+  setTensor(value?: Tensor): void;
+
+  hasString(): boolean;
+  clearString(): void;
+  getString(): string;
+  setString(value: string): void;
+
+  hasInt64(): boolean;
+  clearInt64(): void;
+  getInt64(): number;
+  setInt64(value: number): void;
+
+  hasFloat(): boolean;
+  clearFloat(): void;
+  getFloat(): number;
+  setFloat(value: number): void;
+
+  hasBool(): boolean;
+  clearBool(): void;
+  getBool(): boolean;
+  setBool(value: boolean): void;
+
+  getValueCase(): Attribute.ValueCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Attribute.AsObject;
+  static toObject(includeInstance: boolean, msg: Attribute): Attribute.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Attribute, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Attribute;
+  static deserializeBinaryFromReader(message: Attribute, reader: jspb.BinaryReader): Attribute;
+}
+
+export namespace Attribute {
+  export type AsObject = {
+    name: string,
+    module?: Module.AsObject,
+    tensor?: Tensor.AsObject,
+    string: string,
+    int64: number,
+    pb_float: number,
+    bool: boolean,
+  }
+
+  export enum ValueCase {
+    VALUE_NOT_SET = 0,
+    MODULE = 3,
+    TENSOR = 4,
+    STRING = 5,
+    INT64 = 6,
+    FLOAT = 7,
+    BOOL = 8,
+  }
+}
+
+export class Module extends jspb.Message {
+  getName(): string;
+  setName(value: string): void;
+
+  clearNamesList(): void;
+  getNamesList(): Array<string>;
+  setNamesList(value: Array<string>): void;
+  addNames(value: string, index?: number): string;
+
+  clearAttributesList(): void;
+  getAttributesList(): Array<Attribute>;
+  setAttributesList(value: Array<Attribute>): void;
+  addAttributes(value?: Attribute, index?: number): Attribute;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Module.AsObject;
+  static toObject(includeInstance: boolean, msg: Module): Module.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Module, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Module;
+  static deserializeBinaryFromReader(message: Module, reader: jspb.BinaryReader): Module;
+}
+
+export namespace Module {
+  export type AsObject = {
+    name: string,
+    namesList: Array<string>,
+    attributesList: Array<Attribute.AsObject>,
+  }
+}
+
+export interface DtypeMap {
+  DT_INVALID: 0;
+  DT_FLOAT32: 1;
+  DT_FLOAT64: 2;
+  DT_FLOAT16: 3;
+  DT_BFLOAT16: 4;
+  DT_COMPLEX32: 5;
+  DT_COMPLEX64: 6;
+  DT_COMPLEX128: 7;
+  DT_UINT8: 8;
+  DT_INT8: 9;
+  DT_INT16: 10;
+  DT_INT32: 11;
+  DT_INT64: 12;
+  DT_BOOL: 13;
+  DT_QUINT8: 14;
+  DT_QINT8: 15;
+  DT_QINT32: 16;
+  DT_QUINT4_2: 17;
+}
+
+export const Dtype: DtypeMap;
+
+export interface AttributeTypeMap {
+  AT_PARAMETER: 0;
+  AT_BUFFER: 1;
+}
+
+export const AttributeType: AttributeTypeMap;
+

package-lock.json

@@ -9,6 +9,8 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
+        "@improbable-eng/grpc-web": "^0.15.0",
+        "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
         "appid": "^1.0.3",
         "discord.js": "^12.5.3",
         "dotenv": "^10.0.0",
@@ -41,6 +43,25 @@
         "node": ">= 6"
       }
     },
+    "node_modules/@improbable-eng/grpc-web": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz",
+      "integrity": "sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg==",
+      "dependencies": {
+        "browser-headers": "^0.4.1"
+      },
+      "peerDependencies": {
+        "google-protobuf": "^3.14.0"
+      }
+    },
+    "node_modules/@improbable-eng/grpc-web-node-http-transport": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web-node-http-transport/-/grpc-web-node-http-transport-0.15.0.tgz",
+      "integrity": "sha512-HLgJfVolGGpjc9DWPhmMmXJx8YGzkek7jcCFO1YYkSOoO81MWRZentPOd/JiKiZuU08wtc4BG+WNuGzsQB5jZA==",
+      "peerDependencies": {
+        "@improbable-eng/grpc-web": ">=0.13.0"
+      }
+    },
     "node_modules/@sindresorhus/is": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.0.1.tgz",
@@ -216,6 +237,11 @@
       "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
       "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg=="
     },
+    "node_modules/browser-headers": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/browser-headers/-/browser-headers-0.4.1.tgz",
+      "integrity": "sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg=="
+    },
     "node_modules/cacheable-lookup": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",
@@ -283,9 +309,9 @@
       "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg=="
     },
     "node_modules/cookiejar": {
-      "version": "2.1.2",
+      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.2.tgz",
+      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz",
-      "integrity": "sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA=="
+      "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw=="
     },
     "node_modules/core-util-is": {
       "version": "1.0.2",
@@ -553,6 +579,12 @@
         "assert-plus": "^1.0.0"
       }
     },
+    "node_modules/google-protobuf": {
+      "version": "3.21.2",
+      "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.2.tgz",
+      "integrity": "sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA==",
+      "peer": true
+    },
     "node_modules/got": {
       "version": "11.8.6",
       "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",
@@ -621,9 +653,9 @@
       }
     },
     "node_modules/http-cache-semantics": {
-      "version": "4.1.0",
+      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz",
-      "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ=="
+      "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ=="
     },
     "node_modules/http-signature": {
       "version": "1.2.0",
@@ -1472,6 +1504,20 @@
         "mime-types": "^2.1.12"
       }
     },
+    "@improbable-eng/grpc-web": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz",
+      "integrity": "sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg==",
+      "requires": {
+        "browser-headers": "^0.4.1"
+      }
+    },
+    "@improbable-eng/grpc-web-node-http-transport": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web-node-http-transport/-/grpc-web-node-http-transport-0.15.0.tgz",
+      "integrity": "sha512-HLgJfVolGGpjc9DWPhmMmXJx8YGzkek7jcCFO1YYkSOoO81MWRZentPOd/JiKiZuU08wtc4BG+WNuGzsQB5jZA==",
+      "requires": {}
+    },
     "@sindresorhus/is": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.0.1.tgz",
@@ -1627,6 +1673,11 @@
       "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
       "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg=="
     },
+    "browser-headers": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/browser-headers/-/browser-headers-0.4.1.tgz",
+      "integrity": "sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg=="
+    },
     "cacheable-lookup": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",
@@ -1682,9 +1733,9 @@
       "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg=="
     },
     "cookiejar": {
-      "version": "2.1.2",
+      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.2.tgz",
+      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz",
-      "integrity": "sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA=="
+      "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw=="
     },
     "core-util-is": {
       "version": "1.0.2",
@@ -1877,6 +1928,12 @@
         "assert-plus": "^1.0.0"
       }
     },
+    "google-protobuf": {
+      "version": "3.21.2",
+      "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.2.tgz",
+      "integrity": "sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA==",
+      "peer": true
+    },
     "got": {
       "version": "11.8.6",
       "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",
@@ -1923,9 +1980,9 @@
       "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw=="
     },
     "http-cache-semantics": {
-      "version": "4.1.0",
+      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz",
-      "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ=="
+      "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ=="
     },
     "http-signature": {
       "version": "1.2.0",

package.json

@@ -13,6 +13,8 @@
   "author": "Expand",
   "license": "ISC",
   "dependencies": {
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
     "appid": "^1.0.3",
     "discord.js": "^12.5.3",
     "dotenv": "^10.0.0",