@slates/proto 1.0.0-rc.12 → 1.0.0-rc.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/proto",
-  "version": "1.0.0-rc.12",
+  "version": "1.0.0-rc.14",
   "publishConfig": {
     "access": "public"
   },
@@ -43,4 +43,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/messages/action.ts

@@ -2,6 +2,19 @@ import z from 'zod';
 import { slatesAction } from '../types';
 import { withRequestTraces } from './tracing';
 
+export let slatesWebhookHttpResponse = z.object({
+  status: z.number().int().min(100).max(599),
+  headers: z.record(z.string(), z.string()),
+  body: z
+    .object({
+      encoding: z.literal('base64'),
+      content: z.string()
+    })
+    .nullable()
+});
+
+export type SlatesWebhookHttpResponse = z.infer<typeof slatesWebhookHttpResponse>;
+
 /**
  * List Actions
  */
@@ -9,7 +22,9 @@ export let slatesMessageActionsListRequest = z.object({
   jsonrpc: z.literal('2.0'),
   method: z.literal('slates/actions.list'),
   id: z.string(),
-  params: z.object({})
+  params: z.object({
+    includeAdapterActions: z.optional(z.nullable(z.boolean()))
+  })
 });
 
 export type SlatesMessageActionsListRequest = z.infer<typeof slatesMessageActionsListRequest>;
@@ -177,7 +192,8 @@ export let slatesMessageActionTriggerWebhookHandleRequest = z.object({
         content: z.string()
       })
       .nullable(),
-    state: z.any().nullable()
+    state: z.any().nullable(),
+    registrationDetails: z.any().nullable().optional()
   })
 });
 
@@ -190,7 +206,8 @@ export let slatesMessageActionTriggerWebhookHandleResponse = z.object({
   id: z.string(),
   result: withRequestTraces({
     inputs: z.array(z.record(z.string(), z.any())),
-    updatedState: z.any().nullable().optional()
+    updatedState: z.any().nullable().optional(),
+    response: slatesWebhookHttpResponse.nullable().optional()
   })
 });
 

package/src/messages/adapter.ts

@@ -0,0 +1,72 @@
+import z from 'zod';
+import { slatesAdapter } from '../types';
+
+/**
+ * List Adapters
+ */
+export let slatesMessageAdaptersListRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/adapters.list'),
+  id: z.string(),
+  params: z.object({
+    includeAdapters: z.optional(z.nullable(z.boolean()))
+  })
+});
+
+export type SlatesMessageAdaptersListRequest = z.infer<
+  typeof slatesMessageAdaptersListRequest
+>;
+
+export let slatesMessageAdaptersListResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    adapters: z.array(slatesAdapter)
+  })
+});
+
+export type SlatesMessageAdaptersListResponse = z.infer<
+  typeof slatesMessageAdaptersListResponse
+>;
+
+/**
+ * Get Adapter
+ */
+export let slatesMessageAdapterGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/adapter.get'),
+  id: z.string(),
+  params: z.object({
+    adapterId: z.string()
+  })
+});
+
+export type SlatesMessageAdapterGetRequest = z.infer<typeof slatesMessageAdapterGetRequest>;
+
+export let slatesMessageAdapterGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    adapter: slatesAdapter
+  })
+});
+
+export type SlatesMessageAdapterGetResponse = z.infer<typeof slatesMessageAdapterGetResponse>;
+
+export type SlatesAdapterRequests =
+  | SlatesMessageAdaptersListRequest
+  | SlatesMessageAdapterGetRequest;
+
+export type SlatesAdapterResponses =
+  | SlatesMessageAdaptersListResponse
+  | SlatesMessageAdapterGetResponse;
+
+export let slatesAdapterResponsesByMethod = {
+  'slates/adapters.list': slatesMessageAdaptersListResponse,
+  'slates/adapter.get': slatesMessageAdapterGetResponse
+};
+
+export let slatesAdapterRequestsByMethod = {
+  'slates/adapters.list': slatesMessageAdaptersListRequest,
+  'slates/adapter.get': slatesMessageAdapterGetRequest
+};

package/src/messages/index.ts

@@ -1,4 +1,5 @@
 export * from './action';
+export * from './adapter';
 export * from './auth';
 export * from './config';
 export * from './controlFlow';
@@ -12,6 +13,12 @@ import {
   slatesActionRequestsByMethod,
   slatesActionResponsesByMethod
 } from './action';
+import {
+  type SlatesAdapterRequests,
+  type SlatesAdapterResponses,
+  slatesAdapterRequestsByMethod,
+  slatesAdapterResponsesByMethod
+} from './adapter';
 import {
   type SlatesAuthNotifications,
   type SlatesAuthRequests,
@@ -46,18 +53,21 @@ export type SlatesNotifications =
 
 export type SlatesRequests =
   | SlatesActionRequests
+  | SlatesAdapterRequests
   | SlatesAuthRequests
   | SlatesConfigRequests
   | SlatesIdentifyRequests;
 
 export type SlatesResponses =
   | SlatesActionResponses
+  | SlatesAdapterResponses
   | SlatesAuthResponses
   | SlatesConfigResponses
   | SlatesIdentifyResponses;
 
 export let slatesResponsesByMethod = {
   ...slatesActionResponsesByMethod,
+  ...slatesAdapterResponsesByMethod,
   ...slatesAuthResponsesByMethod,
   ...slatesConfigResponsesByMethod,
   ...slatesIdentifyResponsesByMethod
@@ -65,6 +75,7 @@ export let slatesResponsesByMethod = {
 
 export let slatesRequestsByMethod = {
   ...slatesActionRequestsByMethod,
+  ...slatesAdapterRequestsByMethod,
   ...slatesAuthRequestsByMethod,
   ...slatesConfigRequestsByMethod,
   ...slatesIdentifyRequestsByMethod

package/src/types/action.ts

@@ -34,12 +34,46 @@ export let slatesActionBase = z.object({
       name: z.string(),
       url: z.string()
     })
-  )
+  ),
+
+  adapter: z.optional(z.nullable(z.string()))
 });
 
 export let slatesActionTool = slatesActionBase.extend({
   type: z.literal('action.tool'),
-  capabilities: z.object({})
+  capabilities: z.object({}),
+  isPublic: z.boolean()
+});
+
+export let slatesWebhookRequestMatcher = z.object({
+  method: z.string().optional(),
+  hasQueryParam: z.string().optional(),
+  hasHeader: z.string().optional(),
+  jsonBodyField: z
+    .object({
+      path: z.string(),
+      equals: z.string().optional()
+    })
+    .optional(),
+  formBodyField: z
+    .object({
+      path: z.string(),
+      equals: z.string().optional()
+    })
+    .optional()
+});
+
+export let slatesWebhookHttp = z.object({
+  methods: z
+    .array(z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']))
+    .optional(),
+  sync: z
+    .object({
+      mode: z.enum(['never', 'match', 'always']),
+      match: z.array(slatesWebhookRequestMatcher).optional(),
+      timeoutMs: z.number().int().positive().max(15_000).optional()
+    })
+    .optional()
 });
 
 export let slatesActionTrigger = slatesActionBase.extend({
@@ -54,7 +88,8 @@ export let slatesActionTrigger = slatesActionBase.extend({
     z.object({
       type: z.literal('webhook'),
       autoRegistration: z.boolean(),
-      autoUnregistration: z.boolean()
+      autoUnregistration: z.boolean(),
+      http: slatesWebhookHttp.optional()
     })
   ])
 });
@@ -65,3 +100,5 @@ export type SlatesAction = z.infer<typeof slatesAction>;
 export type SlatesActionTool = z.infer<typeof slatesActionTool>;
 export type SlatesActionTrigger = z.infer<typeof slatesActionTrigger>;
 export type SlatesActionScopes = z.infer<typeof slatesActionScopes>;
+export type SlatesWebhookRequestMatcher = z.infer<typeof slatesWebhookRequestMatcher>;
+export type SlatesWebhookHttp = z.infer<typeof slatesWebhookHttp>;

package/src/types/adapter.ts

@@ -0,0 +1,15 @@
+import z from 'zod';
+
+export let slatesAdapter = z.object({
+  id: z.string(),
+  name: z.string(),
+
+  capabilities: z.array(
+    z.object({
+      id: z.string(),
+      value: z.any()
+    })
+  )
+});
+
+export type SlateAdapter = z.infer<typeof slatesAdapter>;

package/src/types/index.ts

@@ -1,3 +1,4 @@
 export * from './action';
+export * from './adapter';
 export * from './authMethod';
 export * from './participant';