@slates/client 1.0.0-rc.2

package/dist/index.module.js

@@ -0,0 +1,383 @@
+// src/client.ts
+import {
+  SLATES_PROTOCOL_VERSION
+} from "@slates/proto";
+import { randomUUID } from "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: 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: 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 = 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
+import {
+  SlatesProviderProtoHandlerManager
+} from "@slates/proto";
+import { createProviderHandler } from "@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 = 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 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);
+export {
+  SlateProtocolError,
+  SlatesProtocolClient,
+  createLocalSlateTransport,
+  createSlatesClient
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@slates/client",
+  "version": "1.0.0-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/**",
+    "dist/**",
+    "README.md",
+    "package.json"
+  ],
+  "author": "Tobias Herber",
+  "license": "FSL 1.1",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.module.js",
+    "default": "./dist/index.module.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.module.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "tsup --config ../../tsup.packages.config.ts --external async_hooks",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@slates/proto": "1.0.0-rc.7",
+    "@slates/provider": "1.0.0-rc.8",
+    "@slates/provider-handler": "1.0.0-rc.7"
+  },
+  "devDependencies": {
+    "@slates/tsconfig": "1.0.0-rc.1",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2"
+  }
+}