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

package/dist/index.cjs

@@ -343,7 +343,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

@@ -95,6 +95,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;
@@ -177,6 +197,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

@@ -95,6 +95,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;
@@ -177,6 +197,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

@@ -316,7 +316,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.14",
   "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.17",
+    "@slates/provider-handler": "1.0.0-rc.19"
   },
   "devDependencies": {
     "@slates/tsconfig": "1.0.0-rc.1",

package/src/client.test.ts

@@ -312,7 +312,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 +436,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();
@@ -618,7 +702,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 +712,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 +745,7 @@ describe('@slates/client local transport', () => {
             component: 'action',
             functionName: 'handleRequest',
             inputCount: 2,
+            hasResponse: true,
             actionId: 'webhook_trigger'
           })
         })
@@ -732,6 +827,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: {

package/src/client.ts

@@ -356,6 +356,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 +377,8 @@ export class SlatesProtocolClient {
             content: encodedBody
           }
         : null,
-      state: d.state ?? null
+      state: d.state ?? null,
+      registrationDetails: d.registrationDetails ?? null
     });
   }