@slates/client 1.0.0-rc.11

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
+});

package/dist/index.d.cts

@@ -0,0 +1,227 @@
+import { SlatesProtocolVersion, SlatesParticipant, SlatesNotifications, SlatesRequests, SlatesResponses, SlatesResponsesByMethod, SlatesMessageProviderIdentifyResponse, SlatesMessageActionsListResponse, SlatesAction, SlatesMessageActionGetResponse, SlatesMessageConfigSchemaGetResponse, SlatesMessageConfigDefaultGetResponse, SlatesMessageConfigChangedResponse, SlateAuthenticationMethod, SlatesMessageAuthMethodGetResponse, SlatesMessageAuthDefaultInputGetResponse, SlatesMessageAuthInputChangedResponse, SlatesMessageAuthOutputGetResponse, SlatesMessageAuthAuthorizationUrlGetResponse, SlatesMessageAuthTokenRefreshHandleResponse, SlatesMessageAuthProfileGetResponse, SlatesMessageActionInvokeResponse, SlatesMessageActionTriggerEventMapResponse, SlatesMessageActionTriggerWebhookRegisterResponse, SlatesMessageActionTriggerWebhookHandleResponse, SlatesMessageActionTriggerWebhookUnregisterResponse } from '@slates/proto';
+import { Slate, SlateLogListener } from '@slates/provider';
+
+type SlatesJsonObject = Record<string, any>;
+type SlatesProtocolMessage = SlatesNotifications | SlatesRequests;
+type SlatesProtocolResponse = SlatesNotifications | SlatesResponses;
+interface SlatesClientState {
+    protocol: SlatesProtocolVersion;
+    participants: SlatesParticipant[];
+    config: SlatesJsonObject | null;
+    auth: {
+        authenticationMethodId: string;
+        output: SlatesJsonObject;
+    } | null;
+    session: {
+        id: string;
+        state: SlatesJsonObject;
+    } | null;
+}
+interface SlatesMessageTransport {
+    send(messages: SlatesProtocolMessage[]): Promise<SlatesProtocolResponse[]>;
+    close?(): Promise<void> | void;
+}
+interface SlatesProtocolClientOptions {
+    transport: SlatesMessageTransport;
+    participants?: SlatesParticipant[];
+    state?: Partial<SlatesClientState>;
+}
+
+declare class SlatesProtocolClient {
+    readonly transport: SlatesProtocolClientOptions['transport'];
+    state: SlatesClientState;
+    constructor(opts: SlatesProtocolClientOptions);
+    setParticipants(participants: SlatesParticipant[]): this;
+    setConfig(config: Record<string, any> | null): this;
+    setAuth(auth: SlatesClientState['auth']): this;
+    clearAuth(): this;
+    setSession(session: SlatesClientState['session']): this;
+    ensureSession(): {
+        id: string;
+        state: SlatesJsonObject;
+    };
+    private buildStateMessages;
+    request<Key extends keyof SlatesResponsesByMethod & SlatesRequests['method']>(method: Key, params: Extract<SlatesRequests, {
+        method: Key;
+    }>['params']): Promise<SlatesResponsesByMethod[Key]['result']>;
+    identify(): Promise<SlatesMessageProviderIdentifyResponse['result']>;
+    listActions(): Promise<SlatesMessageActionsListResponse['result']>;
+    listTools(): Promise<SlatesAction[]>;
+    listTriggers(): Promise<SlatesAction[]>;
+    getAction(actionId: string): Promise<SlatesMessageActionGetResponse['result']>;
+    getTool(actionId: string): Promise<{
+        id: string;
+        name: string;
+        inputSchema: Record<string, any>;
+        outputSchema: Record<string, any>;
+        type: "action.tool";
+        capabilities: Record<string, never>;
+        description?: string | undefined;
+        instructions?: string[] | undefined;
+        constraints?: string[] | undefined;
+        tags?: {
+            destructive?: boolean | undefined;
+            readOnly?: boolean | undefined;
+        } | undefined;
+        metadata?: Record<string, any> | undefined;
+        scopes?: {
+            AND: {
+                OR: string[];
+            }[];
+        } | undefined;
+    }>;
+    getTrigger(actionId: string): Promise<{
+        id: string;
+        name: string;
+        inputSchema: Record<string, any>;
+        outputSchema: Record<string, any>;
+        type: "action.trigger";
+        capabilities: Record<string, never>;
+        invocation: {
+            type: "polling";
+            intervalSeconds: number;
+        } | {
+            type: "webhook";
+            autoRegistration: boolean;
+            autoUnregistration: boolean;
+        };
+        description?: string | undefined;
+        instructions?: string[] | undefined;
+        constraints?: string[] | undefined;
+        tags?: {
+            destructive?: boolean | undefined;
+            readOnly?: boolean | undefined;
+        } | undefined;
+        metadata?: Record<string, any> | undefined;
+        scopes?: {
+            AND: {
+                OR: string[];
+            }[];
+        } | undefined;
+    }>;
+    getConfigSchema(): Promise<SlatesMessageConfigSchemaGetResponse['result']>;
+    getDefaultConfig(): Promise<SlatesMessageConfigDefaultGetResponse['result']>;
+    updateConfig(previousConfig: Record<string, any> | null, newConfig: Record<string, any>): Promise<SlatesMessageConfigChangedResponse['result']>;
+    listAuthMethods(): Promise<{
+        authenticationMethods: SlateAuthenticationMethod[];
+    }>;
+    getAuthMethod(authenticationMethodId: string): Promise<SlatesMessageAuthMethodGetResponse['result']>;
+    getDefaultAuthInput(authenticationMethodId: string): Promise<SlatesMessageAuthDefaultInputGetResponse['result']>;
+    updateAuthInput(d: {
+        authenticationMethodId: string;
+        previousInput: Record<string, any> | null;
+        newInput: Record<string, any>;
+    }): Promise<SlatesMessageAuthInputChangedResponse['result']>;
+    getAuthOutput(d: {
+        authenticationMethodId: string;
+        input: Record<string, any>;
+    }): Promise<SlatesMessageAuthOutputGetResponse['result']>;
+    getAuthorizationUrl(d: {
+        authenticationMethodId: string;
+        redirectUri: string;
+        state: string;
+        input: Record<string, any>;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+    }): Promise<SlatesMessageAuthAuthorizationUrlGetResponse['result']>;
+    handleAuthorizationCallback(d: {
+        authenticationMethodId: string;
+        code: string;
+        state: string;
+        redirectUri: string;
+        input: Record<string, any>;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        callbackParams?: Record<string, string>;
+        callbackState?: Record<string, any>;
+    }): Promise<{
+        output: Record<string, any>;
+        input?: Record<string, any>;
+        scopes?: string[];
+    }>;
+    refreshToken(d: {
+        authenticationMethodId: string;
+        output: Record<string, any>;
+        input: Record<string, any>;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+    }): Promise<SlatesMessageAuthTokenRefreshHandleResponse['result']>;
+    getAuthProfile(d: {
+        authenticationMethodId: string;
+        output: Record<string, any>;
+        input: Record<string, any>;
+        scopes: string[];
+    }): Promise<SlatesMessageAuthProfileGetResponse['result']>;
+    invokeTool(actionId: string, input: Record<string, any>): Promise<SlatesMessageActionInvokeResponse['result']>;
+    mapTriggerEvent(actionId: string, input: Record<string, any>): Promise<SlatesMessageActionTriggerEventMapResponse['result']>;
+    registerTriggerWebhook(actionId: string, webhookBaseUrl: string): Promise<SlatesMessageActionTriggerWebhookRegisterResponse['result']>;
+    handleTriggerWebhook(d: {
+        actionId: string;
+        url: string;
+        method: string;
+        headers?: Record<string, string>;
+        body?: string | Uint8Array | null;
+        state?: any;
+    }): Promise<SlatesMessageActionTriggerWebhookHandleResponse['result']>;
+    unregisterTriggerWebhook(d: {
+        actionId: string;
+        webhookBaseUrl: string;
+        registrationDetails: any;
+        state?: any;
+    }): Promise<SlatesMessageActionTriggerWebhookUnregisterResponse['result']>;
+    close(): Promise<void>;
+}
+
+type SlateProtocolErrorSource = 'provider' | 'transport';
+type SlateProtocolErrorKind = 'declaration' | 'validation' | 'request' | 'auth' | 'config' | 'resource' | 'payment' | 'upstream' | 'transport' | 'internal';
+interface SlateProtocolErrorResponse {
+    code: string;
+    message: string;
+    kind: SlateProtocolErrorKind;
+    retryable?: boolean;
+    status?: number;
+    issues?: Record<string, unknown>[];
+    provider?: Record<string, unknown>;
+    upstream?: Record<string, unknown>;
+    baggage?: Record<string, unknown>;
+    requestTraces?: Record<string, unknown>[];
+    [key: string]: unknown;
+}
+declare class SlateProtocolError extends Error {
+    cause?: unknown;
+    data: SlateProtocolErrorResponse;
+    source: SlateProtocolErrorSource;
+    constructor(data: SlateProtocolErrorResponse, source?: SlateProtocolErrorSource, cause?: unknown);
+    get code(): string;
+    get kind(): SlateProtocolErrorKind;
+    get retryable(): boolean | undefined;
+    get status(): number | undefined;
+    toJSON(): {
+        source: SlateProtocolErrorSource;
+        code: string;
+        message: string;
+        kind: SlateProtocolErrorKind;
+        retryable?: boolean;
+        status?: number;
+        issues?: Record<string, unknown>[];
+        provider?: Record<string, unknown>;
+        upstream?: Record<string, unknown>;
+        baggage?: Record<string, unknown>;
+        requestTraces?: Record<string, unknown>[];
+    };
+    static is(error: unknown): error is SlateProtocolError;
+    static fromResponse(error: unknown, source?: SlateProtocolErrorSource): SlateProtocolError;
+    static fromUnknown(error: unknown, defaults?: Partial<SlateProtocolErrorResponse>, source?: SlateProtocolErrorSource): SlateProtocolError;
+}
+
+declare let createLocalSlateTransport: <ConfigType extends {}, AuthType extends {}>(d: {
+    slate: Slate<ConfigType, AuthType>;
+    listeners?: SlateLogListener[];
+}) => SlatesMessageTransport;
+
+declare let createSlatesClient: (opts: SlatesProtocolClientOptions) => SlatesProtocolClient;
+
+export { SlateProtocolError, type SlateProtocolErrorKind, type SlateProtocolErrorResponse, type SlateProtocolErrorSource, type SlatesClientState, type SlatesJsonObject, type SlatesMessageTransport, SlatesProtocolClient, type SlatesProtocolClientOptions, type SlatesProtocolMessage, type SlatesProtocolResponse, createLocalSlateTransport, createSlatesClient };