@slates/client 1.0.0-rc.13 → 1.0.0-rc.15

package/dist/index.cjs

@@ -237,7 +237,9 @@ var SlatesProtocolClient = class {
   }
   async listTools() {
     let result = await this.listActions();
-    return result.actions.filter((action) => action.type === "action.tool");
+    return result.actions.filter(
+      (action) => action.type === "action.tool"
+    );
   }
   async listTriggers() {
     let result = await this.listActions();
@@ -343,7 +345,8 @@ var SlatesProtocolClient = class {
         encoding: "base64",
         content: encodedBody
       } : null,
-      state: d.state ?? null
+      state: d.state ?? null,
+      registrationDetails: d.registrationDetails ?? null
     });
   }
   async unregisterTriggerWebhook(d) {

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-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 { SlatesProtocolVersion, SlatesParticipant, SlatesNotifications, SlatesRequests, SlatesResponses, SlatesResponsesByMethod, SlatesMessageProviderIdentifyResponse, SlatesMessageActionsListResponse, SlatesActionTool, 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>;
@@ -46,7 +46,7 @@ declare class SlatesProtocolClient {
     }>['params']): Promise<SlatesResponsesByMethod[Key]['result']>;
     identify(): Promise<SlatesMessageProviderIdentifyResponse['result']>;
     listActions(): Promise<SlatesMessageActionsListResponse['result']>;
-    listTools(): Promise<SlatesAction[]>;
+    listTools(): Promise<SlatesActionTool[]>;
     listTriggers(): Promise<SlatesAction[]>;
     getAction(actionId: string): Promise<SlatesMessageActionGetResponse['result']>;
     getTool(actionId: string): Promise<{
@@ -61,6 +61,7 @@ declare class SlatesProtocolClient {
         }[];
         type: "action.tool";
         capabilities: Record<string, never>;
+        isPublic: boolean;
         description?: string | undefined;
         instructions?: string[] | undefined;
         constraints?: string[] | undefined;
@@ -75,6 +76,7 @@ declare class SlatesProtocolClient {
             }[];
         } | undefined;
         authMethods?: string[] | undefined;
+        adapter?: string | null | undefined;
     }>;
     getTrigger(actionId: string): Promise<{
         id: string;
@@ -95,6 +97,26 @@ declare class SlatesProtocolClient {
             type: "webhook";
             autoRegistration: boolean;
             autoUnregistration: boolean;
+            http?: {
+                methods?: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS")[] | undefined;
+                sync?: {
+                    mode: "match" | "never" | "always";
+                    match?: {
+                        method?: string | undefined;
+                        hasQueryParam?: string | undefined;
+                        hasHeader?: string | undefined;
+                        jsonBodyField?: {
+                            path: string;
+                            equals?: string | undefined;
+                        } | undefined;
+                        formBodyField?: {
+                            path: string;
+                            equals?: string | undefined;
+                        } | undefined;
+                    }[] | undefined;
+                    timeoutMs?: number | undefined;
+                } | undefined;
+            } | undefined;
         };
         description?: string | undefined;
         instructions?: string[] | undefined;
@@ -110,6 +132,7 @@ declare class SlatesProtocolClient {
             }[];
         } | undefined;
         authMethods?: string[] | undefined;
+        adapter?: string | null | undefined;
     }>;
     getConfigSchema(): Promise<SlatesMessageConfigSchemaGetResponse['result']>;
     getDefaultConfig(): Promise<SlatesMessageConfigDefaultGetResponse['result']>;
@@ -177,6 +200,7 @@ declare class SlatesProtocolClient {
         headers?: Record<string, string>;
         body?: string | Uint8Array | null;
         state?: any;
+        registrationDetails?: any;
     }): Promise<SlatesMessageActionTriggerWebhookHandleResponse['result']>;
     unregisterTriggerWebhook(d: {
         actionId: string;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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 { SlatesProtocolVersion, SlatesParticipant, SlatesNotifications, SlatesRequests, SlatesResponses, SlatesResponsesByMethod, SlatesMessageProviderIdentifyResponse, SlatesMessageActionsListResponse, SlatesActionTool, 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>;
@@ -46,7 +46,7 @@ declare class SlatesProtocolClient {
     }>['params']): Promise<SlatesResponsesByMethod[Key]['result']>;
     identify(): Promise<SlatesMessageProviderIdentifyResponse['result']>;
     listActions(): Promise<SlatesMessageActionsListResponse['result']>;
-    listTools(): Promise<SlatesAction[]>;
+    listTools(): Promise<SlatesActionTool[]>;
     listTriggers(): Promise<SlatesAction[]>;
     getAction(actionId: string): Promise<SlatesMessageActionGetResponse['result']>;
     getTool(actionId: string): Promise<{
@@ -61,6 +61,7 @@ declare class SlatesProtocolClient {
         }[];
         type: "action.tool";
         capabilities: Record<string, never>;
+        isPublic: boolean;
         description?: string | undefined;
         instructions?: string[] | undefined;
         constraints?: string[] | undefined;
@@ -75,6 +76,7 @@ declare class SlatesProtocolClient {
             }[];
         } | undefined;
         authMethods?: string[] | undefined;
+        adapter?: string | null | undefined;
     }>;
     getTrigger(actionId: string): Promise<{
         id: string;
@@ -95,6 +97,26 @@ declare class SlatesProtocolClient {
             type: "webhook";
             autoRegistration: boolean;
             autoUnregistration: boolean;
+            http?: {
+                methods?: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS")[] | undefined;
+                sync?: {
+                    mode: "match" | "never" | "always";
+                    match?: {
+                        method?: string | undefined;
+                        hasQueryParam?: string | undefined;
+                        hasHeader?: string | undefined;
+                        jsonBodyField?: {
+                            path: string;
+                            equals?: string | undefined;
+                        } | undefined;
+                        formBodyField?: {
+                            path: string;
+                            equals?: string | undefined;
+                        } | undefined;
+                    }[] | undefined;
+                    timeoutMs?: number | undefined;
+                } | undefined;
+            } | undefined;
         };
         description?: string | undefined;
         instructions?: string[] | undefined;
@@ -110,6 +132,7 @@ declare class SlatesProtocolClient {
             }[];
         } | undefined;
         authMethods?: string[] | undefined;
+        adapter?: string | null | undefined;
     }>;
     getConfigSchema(): Promise<SlatesMessageConfigSchemaGetResponse['result']>;
     getDefaultConfig(): Promise<SlatesMessageConfigDefaultGetResponse['result']>;
@@ -177,6 +200,7 @@ declare class SlatesProtocolClient {
         headers?: Record<string, string>;
         body?: string | Uint8Array | null;
         state?: any;
+        registrationDetails?: any;
     }): Promise<SlatesMessageActionTriggerWebhookHandleResponse['result']>;
     unregisterTriggerWebhook(d: {
         actionId: string;

package/dist/index.module.js

@@ -210,7 +210,9 @@ var SlatesProtocolClient = class {
   }
   async listTools() {
     let result = await this.listActions();
-    return result.actions.filter((action) => action.type === "action.tool");
+    return result.actions.filter(
+      (action) => action.type === "action.tool"
+    );
   }
   async listTriggers() {
     let result = await this.listActions();
@@ -316,7 +318,8 @@ var SlatesProtocolClient = class {
         encoding: "base64",
         content: encodedBody
       } : null,
-      state: d.state ?? null
+      state: d.state ?? null,
+      registrationDetails: d.registrationDetails ?? null
     });
   }
   async unregisterTriggerWebhook(d) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/client",
-  "version": "1.0.0-rc.13",
+  "version": "1.0.0-rc.15",
   "publishConfig": {
     "access": "public"
   },
@@ -31,9 +31,9 @@
     "biome:check": "biome check --write src"
   },
   "dependencies": {
-    "@slates/proto": "1.0.0-rc.12",
-    "@slates/provider": "1.0.0-rc.16",
-    "@slates/provider-handler": "1.0.0-rc.18"
+    "@slates/proto": "1.0.0-rc.13",
+    "@slates/provider": "1.0.0-rc.18",
+    "@slates/provider-handler": "1.0.0-rc.20"
   },
   "devDependencies": {
     "@slates/tsconfig": "1.0.0-rc.1",

package/src/client.test.ts

@@ -4,6 +4,7 @@ import {
   SlateAuth,
   SlateConfig,
   type SlateLogEntry,
+  SlatePublicTool,
   SlateSpecification,
   SlateTool,
   SlateTrigger
@@ -312,7 +313,14 @@ let createTriggerTraceSlate = () => {
     )
     .webhook({
       handleRequest: async () => ({
-        inputs: [{ id: 'webhook-1' }, { id: 'webhook-2' }]
+        inputs: [{ id: 'webhook-1' }, { id: 'webhook-2' }],
+        response: {
+          status: 202,
+          headers: {
+            'x-trigger-result': 'accepted'
+          },
+          body: 'accepted'
+        }
       }),
       handleEvent: async ctx => ({
         id: ctx.input.id,
@@ -429,6 +437,83 @@ let createOauthConfigSlate = (seenConfig: SeenOAuthConfig) => {
   });
 };
 
+type TokenConfig = {
+  prefix: string;
+};
+
+type SeenTokenConfig = Partial<Record<'output' | 'profile', TokenConfig>>;
+
+let getRequiredTokenConfig = (ctx: { config?: Record<string, unknown> }): TokenConfig => {
+  expect(ctx.config).toBeDefined();
+  return ctx.config as TokenConfig;
+};
+
+type TokenAuthOutputContext = {
+  input: { token: string };
+  config?: Record<string, unknown>;
+};
+
+type TokenAuthProfileContext = {
+  output: { token: string };
+  config?: Record<string, unknown>;
+};
+
+let createTokenConfigSlate = (seenConfig: SeenTokenConfig) => {
+  let config = SlateConfig.create(
+    z.object({
+      prefix: z.string()
+    })
+  );
+
+  let auth = SlateAuth.create<{ token: string }>()
+    .output(
+      z.object({
+        token: z.string()
+      })
+    )
+    .addTokenAuth({
+      type: 'auth.token',
+      key: 'token_auth',
+      name: 'Token Auth',
+      inputSchema: z.object({
+        token: z.string()
+      }),
+      getOutput: async (ctx: TokenAuthOutputContext) => {
+        let currentConfig = getRequiredTokenConfig(ctx);
+        seenConfig.output = currentConfig;
+        return {
+          output: {
+            token: `${currentConfig.prefix}:${ctx.input.token}`
+          }
+        };
+      },
+      getProfile: async (ctx: TokenAuthProfileContext) => {
+        let currentConfig = getRequiredTokenConfig(ctx);
+        seenConfig.profile = currentConfig;
+        return {
+          profile: {
+            prefix: currentConfig.prefix,
+            token: ctx.output.token
+          }
+        };
+      }
+    });
+
+  let spec = SlateSpecification.create({
+    key: 'token-config-slate',
+    name: 'Token Config Slate',
+    description: 'A slate that reads config in token auth hooks',
+    config,
+    auth
+  });
+
+  return Slate.create({
+    spec,
+    tools: [],
+    triggers: []
+  });
+};
+
 describe('@slates/client local transport', () => {
   it('discovers auth/config and invokes tools with session state', async () => {
     let slate = createDemoSlate();
@@ -463,6 +548,7 @@ describe('@slates/client local transport', () => {
       ]
     });
     expect(actions[0]!.authMethods).toEqual(['token_auth']);
+    expect(actions[0]!.isPublic).toBe(false);
 
     let configSchema = await client.getConfigSchema();
     expect(configSchema.schema.properties.prefix.type).toBe('string');
@@ -618,7 +704,7 @@ describe('@slates/client local transport', () => {
       state: null
     });
 
-    await client.request('slates/action.trigger.webhook_handle', {
+    let webhookResult = await client.request('slates/action.trigger.webhook_handle', {
       actionId: 'webhook_trigger',
       url: 'https://example.com/webhook',
       method: 'POST',
@@ -628,6 +714,16 @@ describe('@slates/client local transport', () => {
       body: null,
       state: null
     });
+    expect(webhookResult.response).toEqual({
+      status: 202,
+      headers: {
+        'x-trigger-result': 'accepted'
+      },
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('accepted').toString('base64')
+      }
+    });
 
     await waitForLogs();
 
@@ -651,6 +747,7 @@ describe('@slates/client local transport', () => {
             component: 'action',
             functionName: 'handleRequest',
             inputCount: 2,
+            hasResponse: true,
             actionId: 'webhook_trigger'
           })
         })
@@ -732,6 +829,49 @@ describe('@slates/client local transport', () => {
     });
   });
 
+  it('passes current profile config into token auth callbacks', async () => {
+    let seenConfig: SeenTokenConfig = {};
+    let client = createSlatesClient({
+      transport: createLocalSlateTransport({
+        slate: createTokenConfigSlate(seenConfig)
+      }),
+      state: {
+        config: {
+          prefix: 'configured'
+        }
+      }
+    });
+
+    let authOutput = await client.getAuthOutput({
+      authenticationMethodId: 'token_auth',
+      input: {
+        token: 'secret-token'
+      }
+    });
+
+    expect(authOutput.output).toEqual({
+      token: 'configured:secret-token'
+    });
+
+    let profile = await client.getAuthProfile({
+      authenticationMethodId: 'token_auth',
+      output: authOutput.output,
+      input: {
+        token: 'secret-token'
+      },
+      scopes: []
+    });
+
+    expect(profile.profile).toEqual({
+      prefix: 'configured',
+      token: 'configured:secret-token'
+    });
+    expect(seenConfig).toEqual({
+      output: { prefix: 'configured' },
+      profile: { prefix: 'configured' }
+    });
+  });
+
   it('throws structured protocol errors for provider responses', async () => {
     let client = createSlatesClient({
       transport: {
@@ -901,4 +1041,114 @@ describe('@slates/client local transport', () => {
       });
     }
   });
+
+  it('lists, gets, and invokes public tools without config or auth', async () => {
+    let config = SlateConfig.create(
+      z.object({
+        prefix: z.string()
+      })
+    );
+    let auth = SlateAuth.create<{ token: string }>()
+      .output(
+        z.object({
+          token: z.string()
+        })
+      )
+      .addTokenAuth({
+        type: 'auth.token',
+        key: 'token_auth',
+        name: 'Token Auth',
+        inputSchema: z.object({
+          token: z.string()
+        }),
+        getOutput: async ctx => ({
+          output: {
+            token: ctx.input.token
+          }
+        })
+      });
+
+    let spec = SlateSpecification.create({
+      key: 'public-tool-slate',
+      name: 'Public Tool Slate',
+      config,
+      auth
+    });
+
+    let echoTool = SlateTool.create(spec, {
+      key: 'echo',
+      name: 'Echo'
+    })
+      .input(
+        z.object({
+          name: z.string()
+        })
+      )
+      .output(
+        z.object({
+          greeting: z.string()
+        })
+      )
+      .handleInvocation(async ctx => ({
+        output: {
+          greeting: `${ctx.config.prefix} ${ctx.input.name}`
+        },
+        message: 'done'
+      }))
+      .build();
+
+    let setupTool = SlatePublicTool.create(spec, {
+      key: 'setup',
+      name: 'Setup'
+    })
+      .input(z.object({}))
+      .output(
+        z.object({
+          docsUrl: z.string()
+        })
+      )
+      .handleInvocation(async ctx => {
+        expect(ctx).not.toHaveProperty('config');
+        expect(ctx).not.toHaveProperty('auth');
+
+        return {
+          output: {
+            docsUrl: 'https://example.com/setup'
+          },
+          message: 'ok'
+        };
+      })
+      .build();
+
+    let client = createSlatesClient({
+      transport: createLocalSlateTransport({
+        slate: Slate.create({
+          spec,
+          tools: [echoTool, setupTool],
+          triggers: []
+        })
+      })
+    });
+
+    let tools = await client.listTools();
+    expect(tools.map(tool => ({ id: tool.id, isPublic: tool.isPublic }))).toEqual([
+      { id: 'echo', isPublic: false },
+      { id: 'setup', isPublic: true }
+    ]);
+
+    let setup = await client.getTool('setup');
+    expect(setup.isPublic).toBe(true);
+
+    let echo = await client.getTool('echo');
+    expect(echo.isPublic).toBe(false);
+
+    let result = await client.invokeTool('setup', {});
+    expect(result.output).toEqual({
+      docsUrl: 'https://example.com/setup'
+    });
+
+    await expect(client.invokeTool('echo', { name: 'Ada' })).rejects.toMatchObject({
+      message: 'Session context has not been initialized'
+    });
+  });
 });

package/src/client.ts

@@ -2,6 +2,7 @@ import {
   SLATES_PROTOCOL_VERSION,
   type SlateAuthenticationMethod,
   type SlatesAction,
+  type SlatesActionTool,
   type SlatesMessageActionGetResponse,
   type SlatesMessageActionInvokeResponse,
   type SlatesMessageActionsListResponse,
@@ -173,9 +174,11 @@ export class SlatesProtocolClient {
     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[]> {
@@ -356,6 +359,7 @@ export class SlatesProtocolClient {
     headers?: Record<string, string>;
     body?: string | Uint8Array | null;
     state?: any;
+    registrationDetails?: any;
   }): Promise<SlatesMessageActionTriggerWebhookHandleResponse['result']> {
     this.ensureSession();
     let encodedBody =
@@ -376,7 +380,8 @@ export class SlatesProtocolClient {
             content: encodedBody
           }
         : null,
-      state: d.state ?? null
+      state: d.state ?? null,
+      registrationDetails: d.registrationDetails ?? null
     });
   }