@slates/client 1.0.0-rc.2 → 1.0.0-rc.21

package/src/client.ts

@@ -1,15 +1,33 @@
 import {
   SLATES_PROTOCOL_VERSION,
-  SlateAuthenticationMethod,
-  SlatesAction,
-  SlatesParticipant,
-  slatesRequestsByMethod,
-  slatesResponsesByMethod
+  type SlateAuthenticationMethod,
+  type SlatesAction,
+  type SlatesActionTool,
+  type SlatesMessageActionGetResponse,
+  type SlatesMessageActionInvokeResponse,
+  type SlatesMessageActionsListResponse,
+  type SlatesMessageActionTriggerEventMapResponse,
+  type SlatesMessageActionTriggerWebhookHandleResponse,
+  type SlatesMessageActionTriggerWebhookRegisterResponse,
+  type SlatesMessageActionTriggerWebhookUnregisterResponse,
+  type SlatesMessageAuthAuthorizationUrlGetResponse,
+  type SlatesMessageAuthDefaultInputGetResponse,
+  type SlatesMessageAuthInputChangedResponse,
+  type SlatesMessageAuthMethodGetResponse,
+  type SlatesMessageAuthOutputGetResponse,
+  type SlatesMessageAuthProfileGetResponse,
+  type SlatesMessageAuthTokenRefreshHandleResponse,
+  type SlatesMessageConfigChangedResponse,
+  type SlatesMessageConfigDefaultGetResponse,
+  type SlatesMessageConfigSchemaGetResponse,
+  type SlatesMessageProviderIdentifyResponse,
+  type SlatesParticipant,
+  type SlatesRequests,
+  type SlatesResponsesByMethod
 } from '@slates/proto';
 import { randomUUID } from 'crypto';
-import z from 'zod';
 import { SlateProtocolError } from './error';
-import { SlatesClientState, SlatesProtocolClientOptions } from './types';
+import type { SlatesClientState, SlatesProtocolClientOptions } from './types';
 
 let createDefaultParticipants = (): SlatesParticipant[] => [
   {
@@ -118,10 +136,10 @@ export class SlatesProtocolClient {
     ];
   }
 
-  async request<Key extends keyof typeof slatesRequestsByMethod>(
+  async request<Key extends keyof SlatesResponsesByMethod & SlatesRequests['method']>(
     method: Key,
-    params: z.infer<(typeof slatesRequestsByMethod)[Key]>['params']
-  ): Promise<z.infer<(typeof slatesResponsesByMethod)[Key]>['result']> {
+    params: Extract<SlatesRequests, { method: Key }>['params']
+  ): Promise<SlatesResponsesByMethod[Key]['result']> {
     let id = randomUUID();
     let responses = await this.transport.send([
       ...this.buildStateMessages(),
@@ -130,7 +148,7 @@ export class SlatesProtocolClient {
         id,
         method,
         params
-      } as z.infer<(typeof slatesRequestsByMethod)[Key]>
+      } as Extract<SlatesRequests, { method: Key }>
     ]);
 
     let response = responses.find(message => 'id' in message && message.id === id) as
@@ -148,17 +166,19 @@ export class SlatesProtocolClient {
     return response.result;
   }
 
-  async identify() {
+  async identify(): Promise<SlatesMessageProviderIdentifyResponse['result']> {
     return this.request('slates/provider.identify', {});
   }
 
-  async listActions() {
+  async listActions(): Promise<SlatesMessageActionsListResponse['result']> {
     return this.request('slates/actions.list', {});
   }
 
-  async listTools(): Promise<SlatesAction[]> {
+  async listTools(): Promise<SlatesActionTool[]> {
     let result = await this.listActions();
-    return result.actions.filter(action => action.type === 'action.tool');
+    return result.actions.filter(
+      (action): action is SlatesActionTool => action.type === 'action.tool'
+    );
   }
 
   async listTriggers(): Promise<SlatesAction[]> {
@@ -166,7 +186,7 @@ export class SlatesProtocolClient {
     return result.actions.filter(action => action.type === 'action.trigger');
   }
 
-  async getAction(actionId: string) {
+  async getAction(actionId: string): Promise<SlatesMessageActionGetResponse['result']> {
     return this.request('slates/action.get', { actionId });
   }
 
@@ -188,18 +208,18 @@ export class SlatesProtocolClient {
     return result.action;
   }
 
-  async getConfigSchema() {
+  async getConfigSchema(): Promise<SlatesMessageConfigSchemaGetResponse['result']> {
     return this.request('slates/config.schema.get', {});
   }
 
-  async getDefaultConfig() {
+  async getDefaultConfig(): Promise<SlatesMessageConfigDefaultGetResponse['result']> {
     return this.request('slates/config.get_default', {});
   }
 
   async updateConfig(
     previousConfig: Record<string, any> | null,
     newConfig: Record<string, any>
-  ) {
+  ): Promise<SlatesMessageConfigChangedResponse['result']> {
     return this.request('slates/config.changed', {
       previousConfig,
       newConfig
@@ -210,13 +230,17 @@ export class SlatesProtocolClient {
     return this.request('slates/auth.methods.list', {});
   }
 
-  async getAuthMethod(authenticationMethodId: string) {
+  async getAuthMethod(
+    authenticationMethodId: string
+  ): Promise<SlatesMessageAuthMethodGetResponse['result']> {
     return this.request('slates/auth.method.get', {
       authenticationMethodId
     });
   }
 
-  async getDefaultAuthInput(authenticationMethodId: string) {
+  async getDefaultAuthInput(
+    authenticationMethodId: string
+  ): Promise<SlatesMessageAuthDefaultInputGetResponse['result']> {
     return this.request('slates/auth.input.get_default', {
       authenticationMethodId
     });
@@ -226,7 +250,7 @@ export class SlatesProtocolClient {
     authenticationMethodId: string;
     previousInput: Record<string, any> | null;
     newInput: Record<string, any>;
-  }) {
+  }): Promise<SlatesMessageAuthInputChangedResponse['result']> {
     return this.request('slates/auth.input.changed', {
       authenticationMethodId: d.authenticationMethodId,
       previousInput: d.previousInput,
@@ -234,7 +258,10 @@ export class SlatesProtocolClient {
     });
   }
 
-  async getAuthOutput(d: { authenticationMethodId: string; input: Record<string, any> }) {
+  async getAuthOutput(d: {
+    authenticationMethodId: string;
+    input: Record<string, any>;
+  }): Promise<SlatesMessageAuthOutputGetResponse['result']> {
     return this.request('slates/auth.output.get', {
       authenticationMethodId: d.authenticationMethodId,
       input: d.input
@@ -249,7 +276,7 @@ export class SlatesProtocolClient {
     clientId: string;
     clientSecret: string;
     scopes: string[];
-  }) {
+  }): Promise<SlatesMessageAuthAuthorizationUrlGetResponse['result']> {
     return this.request('slates/auth.authorization_url.get', d);
   }
 
@@ -262,6 +289,7 @@ export class SlatesProtocolClient {
     clientId: string;
     clientSecret: string;
     scopes: string[];
+    callbackParams?: Record<string, string>;
     callbackState?: Record<string, any>;
   }): Promise<{
     output: Record<string, any>;
@@ -278,7 +306,7 @@ export class SlatesProtocolClient {
     clientId: string;
     clientSecret: string;
     scopes: string[];
-  }) {
+  }): Promise<SlatesMessageAuthTokenRefreshHandleResponse['result']> {
     return this.request('slates/auth.token_refresh.handle', d);
   }
 
@@ -287,11 +315,14 @@ export class SlatesProtocolClient {
     output: Record<string, any>;
     input: Record<string, any>;
     scopes: string[];
-  }) {
+  }): Promise<SlatesMessageAuthProfileGetResponse['result']> {
     return this.request('slates/auth.profile.get', d);
   }
 
-  async invokeTool(actionId: string, input: Record<string, any>) {
+  async invokeTool(
+    actionId: string,
+    input: Record<string, any>
+  ): Promise<SlatesMessageActionInvokeResponse['result']> {
     this.ensureSession();
     return this.request('slates/action.tool.invoke', {
       actionId,
@@ -299,7 +330,10 @@ export class SlatesProtocolClient {
     });
   }
 
-  async mapTriggerEvent(actionId: string, input: Record<string, any>) {
+  async mapTriggerEvent(
+    actionId: string,
+    input: Record<string, any>
+  ): Promise<SlatesMessageActionTriggerEventMapResponse['result']> {
     this.ensureSession();
     return this.request('slates/action.trigger.map_event', {
       actionId,
@@ -307,7 +341,10 @@ export class SlatesProtocolClient {
     });
   }
 
-  async registerTriggerWebhook(actionId: string, webhookBaseUrl: string) {
+  async registerTriggerWebhook(
+    actionId: string,
+    webhookBaseUrl: string
+  ): Promise<SlatesMessageActionTriggerWebhookRegisterResponse['result']> {
     this.ensureSession();
     return this.request('slates/action.trigger.webhook_register', {
       actionId,
@@ -322,7 +359,8 @@ export class SlatesProtocolClient {
     headers?: Record<string, string>;
     body?: string | Uint8Array | null;
     state?: any;
-  }) {
+    registrationDetails?: any;
+  }): Promise<SlatesMessageActionTriggerWebhookHandleResponse['result']> {
     this.ensureSession();
     let encodedBody =
       typeof d.body === 'string'
@@ -342,7 +380,8 @@ export class SlatesProtocolClient {
             content: encodedBody
           }
         : null,
-      state: d.state ?? null
+      state: d.state ?? null,
+      registrationDetails: d.registrationDetails ?? null
     });
   }
 
@@ -351,7 +390,7 @@ export class SlatesProtocolClient {
     webhookBaseUrl: string;
     registrationDetails: any;
     state?: any;
-  }) {
+  }): Promise<SlatesMessageActionTriggerWebhookUnregisterResponse['result']> {
     this.ensureSession();
     return this.request('slates/action.trigger.webhook_unregister', {
       actionId: d.actionId,

package/src/error.ts

@@ -18,10 +18,11 @@ export interface SlateProtocolErrorResponse {
   kind: SlateProtocolErrorKind;
   retryable?: boolean;
   status?: number;
-  issues?: Array<Record<string, unknown>>;
+  issues?: Record<string, unknown>[];
   provider?: Record<string, unknown>;
   upstream?: Record<string, unknown>;
   baggage?: Record<string, unknown>;
+  requestTraces?: Record<string, unknown>[];
   [key: string]: unknown;
 }
 
@@ -61,7 +62,8 @@ let normalizeResponse = (
     let code =
       typeof error.code === 'string'
         ? error.code
-        : defaults.code ?? (source === 'transport' ? 'transport.invoke_failed' : 'internal.unexpected');
+        : (defaults.code ??
+          (source === 'transport' ? 'transport.invoke_failed' : 'internal.unexpected'));
 
     return {
       ...defaults,
@@ -69,13 +71,15 @@ let normalizeResponse = (
       code,
       message: error.message,
       kind:
-        (typeof error.kind === 'string' ? (error.kind as SlateProtocolErrorKind) : defaults.kind) ??
-        inferKindFromCode(code)
+        (typeof error.kind === 'string'
+          ? (error.kind as SlateProtocolErrorKind)
+          : defaults.kind) ?? inferKindFromCode(code)
     };
   }
 
   let code =
-    defaults.code ?? (source === 'transport' ? 'transport.invoke_failed' : 'internal.unexpected');
+    defaults.code ??
+    (source === 'transport' ? 'transport.invoke_failed' : 'internal.unexpected');
 
   return {
     ...defaults,
@@ -83,13 +87,11 @@ let normalizeResponse = (
     message:
       error instanceof Error
         ? error.message
-        : defaults.message ?? 'The slate returned an unexpected error.',
+        : (defaults.message ?? 'The slate returned an unexpected error.'),
     kind: defaults.kind ?? inferKindFromCode(code),
     baggage: {
       ...(defaults.baggage ?? {}),
-      ...(error instanceof Error
-        ? { originalName: error.name }
-        : { originalValue: error })
+      ...(error instanceof Error ? { originalName: error.name } : { originalValue: error })
     }
   };
 };

package/src/index.ts

@@ -1,5 +1,5 @@
 import { SlatesProtocolClient } from './client';
-import { SlatesProtocolClientOptions } from './types';
+import type { SlatesProtocolClientOptions } from './types';
 
 export * from './client';
 export * from './error';

package/src/transport.ts

@@ -1,13 +1,13 @@
 import {
-  SlatesNotifications,
+  type SlatesNotifications,
   SlatesProviderProtoHandlerManager,
-  SlatesRequests,
-  SlatesResponses
+  type SlatesRequests,
+  type SlatesResponses
 } from '@slates/proto';
-import { Slate, SlateLogListener } from '@slates/provider';
+import type { Slate, SlateLogListener } from '@slates/provider';
 import { createProviderHandler } from '@slates/provider-handler';
 import { SlateProtocolError } from './error';
-import { SlatesMessageTransport } from './types';
+import type { SlatesMessageTransport } from './types';
 
 type ProviderMessage = SlatesNotifications | SlatesRequests;
 type ProviderResponse = SlatesNotifications | SlatesResponses;
@@ -39,7 +39,7 @@ export let createLocalSlateTransport = <ConfigType extends {}, AuthType extends
       let responses: ProviderResponse[] = [];
 
       for (let message of messages as ProviderMessage[]) {
-        let response;
+        let response: any;
         try {
           response = await SlatesProviderProtoHandlerManager.handleInput(manager, message);
         } catch (error) {

package/src/types.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   SlatesNotifications,
   SlatesParticipant,
   SlatesProtocolVersion,