@slates/client 1.0.0-rc.2

package/dist/index.cjs

@@ -0,0 +1,409 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SlateProtocolError: () => SlateProtocolError,
+  SlatesProtocolClient: () => SlatesProtocolClient,
+  createLocalSlateTransport: () => createLocalSlateTransport,
+  createSlatesClient: () => createSlatesClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_proto = require("@slates/proto");
+var import_crypto = require("crypto");
+
+// src/error.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSlateErrorResponse = (error) => isRecord(error) && typeof error.code === "string" && typeof error.message === "string";
+var inferKindFromCode = (code) => {
+  if (code.startsWith("declaration.")) return "declaration";
+  if (code.startsWith("input.")) return "validation";
+  if (code.startsWith("request.")) return "request";
+  if (code.startsWith("config.")) return "config";
+  if (code.startsWith("auth.") || code.startsWith("permission.")) return "auth";
+  if (code.startsWith("resource.")) return "resource";
+  if (code.startsWith("payment.")) return "payment";
+  if (code.startsWith("transport.")) return "transport";
+  if (code.startsWith("upstream.")) return "upstream";
+  return "internal";
+};
+var normalizeResponse = (error, source, defaults = {}) => {
+  if (isSlateErrorResponse(error)) {
+    return {
+      ...defaults,
+      ...error,
+      kind: error.kind ?? inferKindFromCode(error.code)
+    };
+  }
+  if (isRecord(error) && typeof error.message === "string") {
+    let code2 = typeof error.code === "string" ? error.code : defaults.code ?? (source === "transport" ? "transport.invoke_failed" : "internal.unexpected");
+    return {
+      ...defaults,
+      ...error,
+      code: code2,
+      message: error.message,
+      kind: (typeof error.kind === "string" ? error.kind : defaults.kind) ?? inferKindFromCode(code2)
+    };
+  }
+  let code = defaults.code ?? (source === "transport" ? "transport.invoke_failed" : "internal.unexpected");
+  return {
+    ...defaults,
+    code,
+    message: error instanceof Error ? error.message : defaults.message ?? "The slate returned an unexpected error.",
+    kind: defaults.kind ?? inferKindFromCode(code),
+    baggage: {
+      ...defaults.baggage ?? {},
+      ...error instanceof Error ? { originalName: error.name } : { originalValue: error }
+    }
+  };
+};
+var SlateProtocolError = class _SlateProtocolError extends Error {
+  cause;
+  data;
+  source;
+  constructor(data, source = "provider", cause) {
+    super(data.message);
+    this.name = "SlateProtocolError";
+    this.data = data;
+    this.source = source;
+    this.cause = cause;
+  }
+  get code() {
+    return this.data.code;
+  }
+  get kind() {
+    return this.data.kind;
+  }
+  get retryable() {
+    return this.data.retryable;
+  }
+  get status() {
+    return this.data.status;
+  }
+  toJSON() {
+    return {
+      ...this.data,
+      source: this.source
+    };
+  }
+  static is(error) {
+    return error instanceof _SlateProtocolError;
+  }
+  static fromResponse(error, source = "provider") {
+    if (_SlateProtocolError.is(error)) return error;
+    return new _SlateProtocolError(normalizeResponse(error, source), source, error);
+  }
+  static fromUnknown(error, defaults = {}, source = "transport") {
+    if (_SlateProtocolError.is(error)) return error;
+    return new _SlateProtocolError(normalizeResponse(error, source, defaults), source, error);
+  }
+};
+
+// src/client.ts
+var createDefaultParticipants = () => [
+  {
+    type: "consumer",
+    id: "slates-client",
+    name: "Slates Client"
+  }
+];
+var SlatesProtocolClient = class {
+  transport;
+  state;
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.state = {
+      protocol: import_proto.SLATES_PROTOCOL_VERSION,
+      participants: opts.participants ?? createDefaultParticipants(),
+      config: opts.state?.config ?? null,
+      auth: opts.state?.auth ?? null,
+      session: opts.state?.session ?? null
+    };
+  }
+  setParticipants(participants) {
+    this.state.participants = participants;
+    return this;
+  }
+  setConfig(config) {
+    this.state.config = config;
+    return this;
+  }
+  setAuth(auth) {
+    this.state.auth = auth;
+    return this;
+  }
+  clearAuth() {
+    this.state.auth = null;
+    return this;
+  }
+  setSession(session) {
+    this.state.session = session;
+    return this;
+  }
+  ensureSession() {
+    if (!this.state.session) {
+      this.state.session = {
+        id: (0, import_crypto.randomUUID)(),
+        state: {}
+      };
+    }
+    return this.state.session;
+  }
+  buildStateMessages() {
+    return [
+      {
+        jsonrpc: "2.0",
+        method: "slates/hello",
+        params: { protocol: this.state.protocol }
+      },
+      {
+        jsonrpc: "2.0",
+        method: "slates/participant.set",
+        params: { participants: this.state.participants }
+      },
+      ...this.state.config ? [
+        {
+          jsonrpc: "2.0",
+          method: "slates/config.set",
+          params: { config: this.state.config }
+        }
+      ] : [],
+      ...this.state.auth ? [
+        {
+          jsonrpc: "2.0",
+          method: "slates/auth.set",
+          params: {
+            authenticationMethodId: this.state.auth.authenticationMethodId,
+            output: this.state.auth.output
+          }
+        }
+      ] : [],
+      ...this.state.session ? [
+        {
+          jsonrpc: "2.0",
+          method: "slates/session.start",
+          params: {
+            sessionId: this.state.session.id,
+            state: this.state.session.state
+          }
+        }
+      ] : []
+    ];
+  }
+  async request(method, params) {
+    let id = (0, import_crypto.randomUUID)();
+    let responses = await this.transport.send([
+      ...this.buildStateMessages(),
+      {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      }
+    ]);
+    let response = responses.find((message) => "id" in message && message.id === id);
+    if (!response) {
+      throw new Error(`No response was returned for method ${String(method)}.`);
+    }
+    if (response.error) {
+      throw SlateProtocolError.fromResponse(response.error);
+    }
+    return response.result;
+  }
+  async identify() {
+    return this.request("slates/provider.identify", {});
+  }
+  async listActions() {
+    return this.request("slates/actions.list", {});
+  }
+  async listTools() {
+    let result = await this.listActions();
+    return result.actions.filter((action) => action.type === "action.tool");
+  }
+  async listTriggers() {
+    let result = await this.listActions();
+    return result.actions.filter((action) => action.type === "action.trigger");
+  }
+  async getAction(actionId) {
+    return this.request("slates/action.get", { actionId });
+  }
+  async getTool(actionId) {
+    let result = await this.getAction(actionId);
+    if (result.action.type !== "action.tool") {
+      throw new Error(`Action ${actionId} is not a tool.`);
+    }
+    return result.action;
+  }
+  async getTrigger(actionId) {
+    let result = await this.getAction(actionId);
+    if (result.action.type !== "action.trigger") {
+      throw new Error(`Action ${actionId} is not a trigger.`);
+    }
+    return result.action;
+  }
+  async getConfigSchema() {
+    return this.request("slates/config.schema.get", {});
+  }
+  async getDefaultConfig() {
+    return this.request("slates/config.get_default", {});
+  }
+  async updateConfig(previousConfig, newConfig) {
+    return this.request("slates/config.changed", {
+      previousConfig,
+      newConfig
+    });
+  }
+  async listAuthMethods() {
+    return this.request("slates/auth.methods.list", {});
+  }
+  async getAuthMethod(authenticationMethodId) {
+    return this.request("slates/auth.method.get", {
+      authenticationMethodId
+    });
+  }
+  async getDefaultAuthInput(authenticationMethodId) {
+    return this.request("slates/auth.input.get_default", {
+      authenticationMethodId
+    });
+  }
+  async updateAuthInput(d) {
+    return this.request("slates/auth.input.changed", {
+      authenticationMethodId: d.authenticationMethodId,
+      previousInput: d.previousInput,
+      newInput: d.newInput
+    });
+  }
+  async getAuthOutput(d) {
+    return this.request("slates/auth.output.get", {
+      authenticationMethodId: d.authenticationMethodId,
+      input: d.input
+    });
+  }
+  async getAuthorizationUrl(d) {
+    return this.request("slates/auth.authorization_url.get", d);
+  }
+  async handleAuthorizationCallback(d) {
+    return this.request("slates/auth.authorization_callback.handle", d);
+  }
+  async refreshToken(d) {
+    return this.request("slates/auth.token_refresh.handle", d);
+  }
+  async getAuthProfile(d) {
+    return this.request("slates/auth.profile.get", d);
+  }
+  async invokeTool(actionId, input) {
+    this.ensureSession();
+    return this.request("slates/action.tool.invoke", {
+      actionId,
+      input
+    });
+  }
+  async mapTriggerEvent(actionId, input) {
+    this.ensureSession();
+    return this.request("slates/action.trigger.map_event", {
+      actionId,
+      input
+    });
+  }
+  async registerTriggerWebhook(actionId, webhookBaseUrl) {
+    this.ensureSession();
+    return this.request("slates/action.trigger.webhook_register", {
+      actionId,
+      webhookBaseUrl
+    });
+  }
+  async handleTriggerWebhook(d) {
+    this.ensureSession();
+    let encodedBody = typeof d.body === "string" ? Buffer.from(d.body, "utf-8").toString("base64") : d.body ? Buffer.from(d.body).toString("base64") : null;
+    return this.request("slates/action.trigger.webhook_handle", {
+      actionId: d.actionId,
+      url: d.url,
+      method: d.method,
+      headers: d.headers ?? {},
+      body: encodedBody ? {
+        encoding: "base64",
+        content: encodedBody
+      } : null,
+      state: d.state ?? null
+    });
+  }
+  async unregisterTriggerWebhook(d) {
+    this.ensureSession();
+    return this.request("slates/action.trigger.webhook_unregister", {
+      actionId: d.actionId,
+      webhookBaseUrl: d.webhookBaseUrl,
+      registrationDetails: d.registrationDetails,
+      state: d.state ?? null
+    });
+  }
+  async close() {
+    await this.transport.close?.();
+  }
+};
+
+// src/transport.ts
+var import_proto2 = require("@slates/proto");
+var import_provider_handler = require("@slates/provider-handler");
+var toTransportError = (value, defaultMessage) => SlateProtocolError.fromUnknown(
+  value,
+  {
+    code: "transport.invoke_failed",
+    kind: "transport",
+    message: defaultMessage,
+    retryable: true,
+    baggage: {
+      response: value
+    }
+  },
+  "transport"
+);
+var createLocalSlateTransport = (d) => {
+  let managerPromise = (0, import_provider_handler.createProviderHandler)(d.slate, d.listeners ?? []).run();
+  return {
+    async send(messages) {
+      let manager = await managerPromise;
+      let responses = [];
+      for (let message of messages) {
+        let response;
+        try {
+          response = await import_proto2.SlatesProviderProtoHandlerManager.handleInput(manager, message);
+        } catch (error) {
+          throw toTransportError(error, "Local slate invocation failed");
+        }
+        if (response) {
+          responses.push(response);
+        }
+      }
+      return responses;
+    }
+  };
+};
+
+// src/index.ts
+var createSlatesClient = (opts) => new SlatesProtocolClient(opts);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SlateProtocolError,
+  SlatesProtocolClient,
+  createLocalSlateTransport,
+  createSlatesClient
+});