@slates/proto 1.0.0-rc.1

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@slates/proto",
+  "version": "1.0.0-rc.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Tobias Herber",
+  "license": "Apache 2",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.module.js",
+    "default": "./dist/index.module.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.umd.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "microbundle"
+  },
+  "dependencies": {
+    "@lowerdeck/emitter": "^1.0.4",
+    "@lowerdeck/error": "^1.0.8",
+    "@toon-format/toon": "^2.1.0",
+    "axios": "^1.13.2",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "microbundle": "^0.15.1",
+    "@slates/tsconfig": "^1.0.0",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2"
+  }
+}

package/src/handler/index.ts

@@ -0,0 +1 @@
+export * from './provider';

package/src/handler/provider.ts

@@ -0,0 +1,162 @@
+import {
+  badRequestError,
+  internalServerError,
+  isServiceError,
+  notFoundError,
+  validationError
+} from '@lowerdeck/error';
+import z from 'zod';
+import {
+  SlatesNotifications,
+  slatesNotificationsByMethod,
+  SlatesRequests,
+  slatesRequestsByMethod,
+  SlatesResponsesByMethod
+} from '../messages';
+
+export class SlatesProviderProtoHandlerManager {
+  #implMap = new Map<
+    string,
+    {
+      type: 'request' | 'notification';
+      handler: Function;
+      schema: z.ZodType<any>;
+    }
+  >();
+
+  onNotification<Method extends SlatesNotifications['method']>(
+    method: Method,
+    handler: (message: Extract<SlatesNotifications, { method: Method }>) => void
+  ) {
+    let schema = slatesNotificationsByMethod[method];
+    if (!schema) {
+      throw new Error(`No schema found for method: ${method}`);
+    }
+
+    this.#implMap.set(method, {
+      type: 'notification',
+      handler,
+      schema
+    });
+  }
+
+  onRequest<Method extends SlatesRequests['method']>(
+    method: Method,
+    cb: (
+      message: Extract<SlatesRequests, { method: Method }>
+    ) => Promise<SlatesResponsesByMethod[Method]['result']>
+  ) {
+    let schema = slatesRequestsByMethod[method];
+    if (!schema) {
+      throw new Error(`No schema found for method: ${method}`);
+    }
+
+    this.#implMap.set(method, {
+      type: 'request',
+      handler: cb,
+      schema
+    });
+  }
+
+  private async _handleInput(input: SlatesNotifications | SlatesRequests) {
+    try {
+      if (typeof input !== 'object' || input === null) {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: badRequestError({ message: 'Invalid input' })
+        };
+      }
+
+      if (input.jsonrpc !== '2.0') {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: badRequestError({ message: 'Invalid jsonrpc version' })
+        };
+      }
+
+      let method = input.method;
+      if (typeof method !== 'string') {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: badRequestError({ message: 'Invalid or missing method' })
+        };
+      }
+
+      let impl = this.#implMap.get(input.method);
+      if (!impl) {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: notFoundError('handler', input.method)
+        };
+      }
+
+      let parsed = impl.schema.safeParse(input);
+      if (!parsed.success) {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: validationError({
+            entity: 'request',
+            message: 'Invalid request parameters',
+            errors: parsed.error.issues.map(i => ({
+              ...i,
+              path: i.path.map(p => String(p))
+            }))
+          })
+        };
+      }
+
+      if (impl.type === 'notification') {
+        await impl.handler(parsed.data);
+        return;
+      }
+
+      let result = await impl.handler(parsed.data);
+
+      return {
+        jsonrpc: '2.0' as const,
+        id: parsed.data.id,
+        result
+      };
+    } catch (err) {
+      if (isServiceError(err)) {
+        return {
+          jsonrpc: '2.0' as const,
+          id: (input as any).id,
+          error: err
+        };
+      }
+
+      console.error(err);
+
+      return {
+        jsonrpc: '2.0' as const,
+        id: (input as any).id,
+        error: internalServerError({ message: 'Internal server error' })
+      };
+    }
+  }
+
+  static async handleInput(
+    manager: SlatesProviderProtoHandlerManager,
+    input: SlatesNotifications | SlatesRequests
+  ) {
+    return manager._handleInput(input);
+  }
+}
+
+export let createSlatesProviderProtoHandler = (
+  cb: (manager: SlatesProviderProtoHandlerManager) => Promise<void>
+) => ({
+  run: async () => {
+    let manager = new SlatesProviderProtoHandlerManager();
+
+    await cb(manager);
+
+    return manager;
+  }
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './handler';
+export * from './messages';
+export * from './types';

package/src/messages/action.ts

@@ -0,0 +1,283 @@
+import z from 'zod';
+import { slatesAction } from '../types';
+
+/**
+ * List Actions
+ */
+export let slatesMessageActionsListRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/actions.list'),
+  id: z.string(),
+  params: z.object({})
+});
+
+export type SlatesMessageActionsListRequest = z.infer<typeof slatesMessageActionsListRequest>;
+
+export let slatesMessageActionsListResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    actions: z.array(slatesAction)
+  })
+});
+
+export type SlatesMessageActionsListResponse = z.infer<
+  typeof slatesMessageActionsListResponse
+>;
+
+/**
+ * Get Action
+ */
+export let slatesMessageActionGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.get'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string()
+  })
+});
+
+export type SlatesMessageActionGetRequest = z.infer<typeof slatesMessageActionGetRequest>;
+
+export let slatesMessageActionGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    action: slatesAction
+  })
+});
+
+export type SlatesMessageActionGetResponse = z.infer<typeof slatesMessageActionGetResponse>;
+
+/**
+ * Invoke Action
+ */
+export let slatesMessageActionInvokeRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.tool.invoke'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    input: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageActionInvokeRequest = z.infer<
+  typeof slatesMessageActionInvokeRequest
+>;
+
+export let slatesMessageActionInvokeResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    output: z.record(z.string(), z.any()),
+    message: z.string().optional()
+  })
+});
+
+export type SlatesMessageActionInvokeResponse = z.infer<
+  typeof slatesMessageActionInvokeResponse
+>;
+
+/**
+ * Map Trigger Event
+ */
+export let slatesMessageActionTriggerEventMapRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.map_event'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    input: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageActionTriggerEventMapRequest = z.infer<
+  typeof slatesMessageActionTriggerEventMapRequest
+>;
+
+export let slatesMessageActionTriggerEventMapResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    type: z.string(),
+    id: z.string(),
+    output: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageActionTriggerEventMapResponse = z.infer<
+  typeof slatesMessageActionTriggerEventMapResponse
+>;
+
+/**
+ * Poll Trigger Events
+ */
+export let slatesMessageActionTriggerEventsPollRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.poll_events'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    state: z.any().nullable()
+  })
+});
+
+export type SlatesMessageActionTriggerEventsPollRequest = z.infer<
+  typeof slatesMessageActionTriggerEventsPollRequest
+>;
+
+export let slatesMessageActionTriggerEventsPollResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    inputs: z.array(z.record(z.string(), z.any())),
+    updatedState: z.any().nullable().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerEventsPollResponse = z.infer<
+  typeof slatesMessageActionTriggerEventsPollResponse
+>;
+
+/**
+ * Handle Webhook Request
+ */
+export let slatesMessageActionTriggerWebhookHandleRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_handle'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    url: z.string(),
+    method: z.string(),
+    headers: z.record(z.string(), z.string()),
+    body: z
+      .object({
+        encoding: z.literal('base64'),
+        content: z.string()
+      })
+      .nullable(),
+    state: z.any().nullable()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookHandleRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookHandleRequest
+>;
+
+export let slatesMessageActionTriggerWebhookHandleResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    inputs: z.array(z.record(z.string(), z.any())),
+    updatedState: z.any().nullable().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookHandleResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookHandleResponse
+>;
+
+/**
+ * Handle Webhook Registration
+ */
+export let slatesMessageActionTriggerWebhookRegisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_register'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    webhookBaseUrl: z.string()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookRegisterRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookRegisterRequest
+>;
+
+export let slatesMessageActionTriggerWebhookRegisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    registrationDetails: z.any(),
+    state: z.any().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookRegisterResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookRegisterResponse
+>;
+
+/**
+ * Handle Webhook Unregistration
+ */
+export let slatesMessageActionTriggerWebhookUnregisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_unregister'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    webhookBaseUrl: z.string(),
+    registrationDetails: z.any(),
+    state: z.any().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookUnregisterRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookUnregisterRequest
+>;
+
+export let slatesMessageActionTriggerWebhookUnregisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({})
+});
+
+export type SlatesMessageActionTriggerWebhookUnregisterResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookUnregisterResponse
+>;
+
+export type SlatesActionRequests =
+  | SlatesMessageActionsListRequest
+  | SlatesMessageActionGetRequest
+  | SlatesMessageActionInvokeRequest
+  | SlatesMessageActionTriggerEventMapRequest
+  | SlatesMessageActionTriggerEventsPollRequest
+  | SlatesMessageActionTriggerWebhookHandleRequest
+  | SlatesMessageActionTriggerWebhookRegisterRequest
+  | SlatesMessageActionTriggerWebhookUnregisterRequest;
+
+export type SlatesActionResponses =
+  | SlatesMessageActionsListResponse
+  | SlatesMessageActionGetResponse
+  | SlatesMessageActionInvokeResponse
+  | SlatesMessageActionTriggerEventMapResponse
+  | SlatesMessageActionTriggerEventsPollResponse
+  | SlatesMessageActionTriggerWebhookHandleResponse
+  | SlatesMessageActionTriggerWebhookRegisterResponse
+  | SlatesMessageActionTriggerWebhookUnregisterResponse;
+
+export let slatesActionResponsesByMethod = {
+  'slates/actions.list': slatesMessageActionsListResponse,
+  'slates/action.get': slatesMessageActionGetResponse,
+  'slates/action.tool.invoke': slatesMessageActionInvokeResponse,
+  'slates/action.trigger.map_event': slatesMessageActionTriggerEventMapResponse,
+  'slates/action.trigger.poll_events': slatesMessageActionTriggerEventsPollResponse,
+  'slates/action.trigger.webhook_handle': slatesMessageActionTriggerWebhookHandleResponse,
+  'slates/action.trigger.webhook_register': slatesMessageActionTriggerWebhookRegisterResponse,
+  'slates/action.trigger.webhook_unregister':
+    slatesMessageActionTriggerWebhookUnregisterResponse
+};
+
+export let slatesActionRequestsByMethod = {
+  'slates/actions.list': slatesMessageActionsListRequest,
+  'slates/action.get': slatesMessageActionGetRequest,
+  'slates/action.tool.invoke': slatesMessageActionInvokeRequest,
+  'slates/action.trigger.map_event': slatesMessageActionTriggerEventMapRequest,
+  'slates/action.trigger.poll_events': slatesMessageActionTriggerEventsPollRequest,
+  'slates/action.trigger.webhook_handle': slatesMessageActionTriggerWebhookHandleRequest,
+  'slates/action.trigger.webhook_register': slatesMessageActionTriggerWebhookRegisterRequest,
+  'slates/action.trigger.webhook_unregister':
+    slatesMessageActionTriggerWebhookUnregisterRequest
+};

package/src/messages/auth.ts

@@ -0,0 +1,354 @@
+import z from 'zod';
+import { slatesAuthenticationMethod } from '../types';
+
+/**
+ * Set Authentication
+ */
+export let slatesMessageSetAuthNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.set'),
+  params: z.object({
+    authenticationMethodId: z.string(),
+    output: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageSetAuthNotification = z.infer<
+  typeof slatesMessageSetAuthNotification
+>;
+
+/**
+ * List Authentication Methods
+ */
+export let slatesMessageAuthMethodsListRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.methods.list'),
+  id: z.string(),
+  params: z.object({})
+});
+
+export type SlatesMessageAuthMethodsListRequest = z.infer<
+  typeof slatesMessageAuthMethodsListRequest
+>;
+
+export let slatesMessageAuthMethodsListResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    authenticationMethods: z.array(slatesAuthenticationMethod)
+  })
+});
+
+export type SlatesMessageAuthMethodsListResponse = z.infer<
+  typeof slatesMessageAuthMethodsListResponse
+>;
+
+/**
+ * Get Authentication Method
+ */
+export let slatesMessageAuthMethodGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.method.get'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string()
+  })
+});
+
+export type SlatesMessageAuthMethodGetRequest = z.infer<
+  typeof slatesMessageAuthMethodGetRequest
+>;
+
+export let slatesMessageAuthMethodGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    authenticationMethod: slatesAuthenticationMethod
+  })
+});
+
+export type SlatesMessageAuthMethodGetResponse = z.infer<
+  typeof slatesMessageAuthMethodGetResponse
+>;
+
+/**
+ * Authentication Input Changed
+ */
+export let slatesMessageAuthInputChangedRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.input.changed'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+    previousInput: z.record(z.string(), z.any()).nullable(),
+    newInput: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageAuthInputChangedRequest = z.infer<
+  typeof slatesMessageAuthInputChangedRequest
+>;
+
+export let slatesMessageAuthInputChangedResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    input: z.record(z.string(), z.any()).optional()
+  })
+});
+
+export type SlatesMessageAuthInputChangedResponse = z.infer<
+  typeof slatesMessageAuthInputChangedResponse
+>;
+
+/**
+ * Get Default Inputs
+ */
+export let slatesMessageAuthDefaultInputGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.input.get_default'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string()
+  })
+});
+
+export type SlatesMessageAuthDefaultInputGetRequest = z.infer<
+  typeof slatesMessageAuthDefaultInputGetRequest
+>;
+
+export let slatesMessageAuthDefaultInputGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    input: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageAuthDefaultInputGetResponse = z.infer<
+  typeof slatesMessageAuthDefaultInputGetResponse
+>;
+
+/**
+ * Get Authorization Url
+ */
+export let slatesMessageAuthAuthorizationUrlGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.authorization_url.get'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+
+    redirectUri: z.string(),
+    state: z.string(),
+    input: z.record(z.string(), z.any()),
+    clientId: z.string(),
+    clientSecret: z.string(),
+    scopes: z.array(z.string())
+  })
+});
+
+export type SlatesMessageAuthAuthorizationUrlGetRequest = z.infer<
+  typeof slatesMessageAuthAuthorizationUrlGetRequest
+>;
+
+export let slatesMessageAuthAuthorizationUrlGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    authorizationUrl: z.string(),
+    input: z.record(z.string(), z.any()).optional()
+  })
+});
+
+export type SlatesMessageAuthAuthorizationUrlGetResponse = z.infer<
+  typeof slatesMessageAuthAuthorizationUrlGetResponse
+>;
+
+/**
+ * Handle Authorization Callback
+ */
+export let slatesMessageAuthAuthorizationCallbackHandleRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.authorization_callback.handle'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+
+    code: z.string(),
+    state: z.string(),
+    redirectUri: z.string(),
+    input: z.record(z.string(), z.any()),
+    clientId: z.string(),
+    clientSecret: z.string(),
+    scopes: z.array(z.string())
+  })
+});
+
+export type SlatesMessageAuthAuthorizationCallbackHandleRequest = z.infer<
+  typeof slatesMessageAuthAuthorizationCallbackHandleRequest
+>;
+
+export let slatesMessageAuthAuthorizationCallbackHandleResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    output: z.record(z.string(), z.any()),
+    input: z.record(z.string(), z.any()).optional()
+  })
+});
+
+export type SlatesMessageAuthAuthorizationCallbackHandleResponse = z.infer<
+  typeof slatesMessageAuthAuthorizationCallbackHandleResponse
+>;
+
+/**
+ * Handle Token Refresh
+ */
+export let slatesMessageAuthTokenRefreshHandleRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.token_refresh.handle'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+
+    output: z.record(z.string(), z.any()),
+    input: z.record(z.string(), z.any()),
+    clientId: z.string(),
+    clientSecret: z.string(),
+    scopes: z.array(z.string())
+  })
+});
+
+export type SlatesMessageAuthTokenRefreshHandleRequest = z.infer<
+  typeof slatesMessageAuthTokenRefreshHandleRequest
+>;
+
+export let slatesMessageAuthTokenRefreshHandleResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    output: z.record(z.string(), z.any()),
+    input: z.record(z.string(), z.any()).optional()
+  })
+});
+
+export type SlatesMessageAuthTokenRefreshHandleResponse = z.infer<
+  typeof slatesMessageAuthTokenRefreshHandleResponse
+>;
+
+/**
+ * Get Profile
+ */
+export let slatesMessageAuthProfileGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.profile.get'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+
+    output: z.record(z.string(), z.any()),
+    input: z.record(z.string(), z.any()),
+    scopes: z.array(z.string())
+  })
+});
+
+export type SlatesMessageAuthProfileGetRequest = z.infer<
+  typeof slatesMessageAuthProfileGetRequest
+>;
+
+export let slatesMessageAuthProfileGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    profile: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageAuthProfileGetResponse = z.infer<
+  typeof slatesMessageAuthProfileGetResponse
+>;
+
+/**
+ * Get Auth Output
+ */
+export let slatesMessageAuthOutputGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/auth.output.get'),
+  id: z.string(),
+  params: z.object({
+    authenticationMethodId: z.string(),
+
+    input: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageAuthOutputGetRequest = z.infer<
+  typeof slatesMessageAuthOutputGetRequest
+>;
+
+export let slatesMessageAuthOutputGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    output: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageAuthOutputGetResponse = z.infer<
+  typeof slatesMessageAuthOutputGetResponse
+>;
+
+export type SlatesAuthRequests =
+  | SlatesMessageAuthMethodsListRequest
+  | SlatesMessageAuthMethodGetRequest
+  | SlatesMessageAuthInputChangedRequest
+  | SlatesMessageAuthDefaultInputGetRequest
+  | SlatesMessageAuthAuthorizationUrlGetRequest
+  | SlatesMessageAuthAuthorizationCallbackHandleRequest
+  | SlatesMessageAuthTokenRefreshHandleRequest
+  | SlatesMessageAuthProfileGetRequest
+  | SlatesMessageAuthOutputGetRequest;
+
+export type SlatesAuthResponses =
+  | SlatesMessageAuthMethodsListResponse
+  | SlatesMessageAuthMethodGetResponse
+  | SlatesMessageAuthInputChangedResponse
+  | SlatesMessageAuthDefaultInputGetResponse
+  | SlatesMessageAuthAuthorizationUrlGetResponse
+  | SlatesMessageAuthAuthorizationCallbackHandleResponse
+  | SlatesMessageAuthTokenRefreshHandleResponse
+  | SlatesMessageAuthProfileGetResponse
+  | SlatesMessageAuthOutputGetResponse;
+
+export type SlatesAuthNotifications = SlatesMessageSetAuthNotification;
+
+export let slatesAuthResponsesByMethod = {
+  'slates/auth.methods.list': slatesMessageAuthMethodsListResponse,
+  'slates/auth.method.get': slatesMessageAuthMethodGetResponse,
+  'slates/auth.input.changed': slatesMessageAuthInputChangedResponse,
+  'slates/auth.input.get_default': slatesMessageAuthDefaultInputGetResponse,
+  'slates/auth.authorization_url.get': slatesMessageAuthAuthorizationUrlGetResponse,
+  'slates/auth.authorization_callback.handle':
+    slatesMessageAuthAuthorizationCallbackHandleResponse,
+  'slates/auth.token_refresh.handle': slatesMessageAuthTokenRefreshHandleResponse,
+  'slates/auth.profile.get': slatesMessageAuthProfileGetResponse,
+  'slates/auth.output.get': slatesMessageAuthOutputGetResponse
+};
+
+export let slatesAuthRequestsByMethod = {
+  'slates/auth.methods.list': slatesMessageAuthMethodsListRequest,
+  'slates/auth.method.get': slatesMessageAuthMethodGetRequest,
+  'slates/auth.input.changed': slatesMessageAuthInputChangedRequest,
+  'slates/auth.input.get_default': slatesMessageAuthDefaultInputGetRequest,
+  'slates/auth.authorization_url.get': slatesMessageAuthAuthorizationUrlGetRequest,
+  'slates/auth.authorization_callback.handle':
+    slatesMessageAuthAuthorizationCallbackHandleRequest,
+  'slates/auth.token_refresh.handle': slatesMessageAuthTokenRefreshHandleRequest,
+  'slates/auth.profile.get': slatesMessageAuthProfileGetRequest,
+  'slates/auth.output.get': slatesMessageAuthOutputGetRequest
+};
+
+export let slatesAuthNotificationsByMethod = {
+  'slates/auth.set': slatesMessageSetAuthNotification
+};

package/src/messages/config.ts

@@ -0,0 +1,134 @@
+import z from 'zod';
+
+/**
+ * Set Config
+ */
+export let slatesMessageSetConfigNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/config.set'),
+  params: z.object({
+    config: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageSetConfigNotification = z.infer<
+  typeof slatesMessageSetConfigNotification
+>;
+
+/**
+ * Get Config Schema
+ */
+export let slatesMessageConfigSchemaGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/config.schema.get'),
+  id: z.string(),
+  params: z.object({})
+});
+
+export type SlatesMessageConfigSchemaGetRequest = z.infer<
+  typeof slatesMessageConfigSchemaGetRequest
+>;
+
+export let slatesMessageConfigSchemaGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    schema: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageConfigSchemaGetResponse = z.infer<
+  typeof slatesMessageConfigSchemaGetResponse
+>;
+
+/**
+ * Config Changed
+ */
+export let slatesMessageConfigChangedRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/config.changed'),
+  params: z.object({
+    previousConfig: z.record(z.string(), z.any()).nullable(),
+    newConfig: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageConfigChangedRequest = z.infer<
+  typeof slatesMessageConfigChangedRequest
+>;
+
+export let slatesMessageConfigChangedResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    success: z.boolean(),
+    config: z.record(z.string(), z.any()).optional(),
+    errors: z
+      .array(
+        z.object({
+          code: z.string(),
+          message: z.string(),
+          path: z.array(z.string()).optional()
+        })
+      )
+      .optional()
+  })
+});
+
+export type SlatesMessageConfigChangedResponse = z.infer<
+  typeof slatesMessageConfigChangedResponse
+>;
+
+/**
+ * Get Default Config
+ */
+export let slatesMessageConfigDefaultGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/config.get_default'),
+  id: z.string(),
+  params: z.object({})
+});
+
+export type SlatesMessageConfigDefaultGetRequest = z.infer<
+  typeof slatesMessageConfigDefaultGetRequest
+>;
+
+export let slatesMessageConfigDefaultGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    config: z.record(z.string(), z.any()).nullable()
+  })
+});
+
+export type SlatesMessageConfigDefaultGetResponse = z.infer<
+  typeof slatesMessageConfigDefaultGetResponse
+>;
+
+export type SlatesConfigRequests =
+  | SlatesMessageConfigSchemaGetRequest
+  | SlatesMessageConfigDefaultGetRequest
+  | SlatesMessageConfigChangedRequest;
+
+export type SlatesConfigResponses =
+  | SlatesMessageConfigSchemaGetResponse
+  | SlatesMessageConfigDefaultGetResponse
+  | SlatesMessageConfigChangedResponse;
+
+export type SlatesConfigNotifications = SlatesMessageSetConfigNotification;
+
+export let slatesConfigResponsesByMethod = {
+  'slates/config.schema.get': slatesMessageConfigSchemaGetResponse,
+  'slates/config.get_default': slatesMessageConfigDefaultGetResponse,
+  'slates/config.changed': slatesMessageConfigChangedResponse
+};
+
+export let slatesConfigRequestsByMethod = {
+  'slates/config.schema.get': slatesMessageConfigSchemaGetRequest,
+  'slates/config.get_default': slatesMessageConfigDefaultGetRequest,
+  'slates/config.changed': slatesMessageConfigChangedRequest
+};
+
+export let slatesConfigNotificationsByMethod = {
+  'slates/config.set': slatesMessageSetConfigNotification
+};

package/src/messages/controlFlow.ts

@@ -0,0 +1,48 @@
+import z from 'zod';
+import { slatesParticipant } from '../types';
+
+export let slatesMessageHelloNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/hello'),
+  params: z.object({
+    protocol: z.literal('slates@2026-01-01')
+  })
+});
+
+export type SlatesMessageHelloNotification = z.infer<typeof slatesMessageHelloNotification>;
+
+export let slatesMessageSetParticipantsNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/participant.set'),
+  params: z.object({
+    participants: z.array(slatesParticipant)
+  })
+});
+
+export type SlatesMessageSetParticipantsNotification = z.infer<
+  typeof slatesMessageSetParticipantsNotification
+>;
+
+export let slatesMessageSessionStartNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/session.start'),
+  params: z.object({
+    sessionId: z.string(),
+    state: z.record(z.string(), z.any())
+  })
+});
+
+export type SlatesMessageSessionStartNotification = z.infer<
+  typeof slatesMessageSessionStartNotification
+>;
+
+export type SlatesControlFlowNotifications =
+  | SlatesMessageHelloNotification
+  | SlatesMessageSetParticipantsNotification
+  | SlatesMessageSessionStartNotification;
+
+export let slatesControlFlowNotificationsByMethod = {
+  'slates/hello': slatesMessageHelloNotification,
+  'slates/participant.set': slatesMessageSetParticipantsNotification,
+  'slates/session.start': slatesMessageSessionStartNotification
+};

package/src/messages/identify.ts

@@ -0,0 +1,43 @@
+import z from 'zod';
+
+export let slatesMessageProviderIdentifyRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/provider.identify'),
+  params: z.object({})
+});
+
+export type SlatesMessageProviderIdentifyRequest = z.infer<
+  typeof slatesMessageProviderIdentifyRequest
+>;
+
+export let slatesMessageProviderIdentifyResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    protocol: z.literal('slates@2026-01-01'),
+
+    provider: z.object({
+      type: z.literal('provider'),
+      id: z.string(),
+      name: z.string(),
+      description: z.string().optional(),
+      metadata: z.record(z.string(), z.any()).optional()
+    })
+  })
+});
+
+export type SlatesMessageProviderIdentifyResponse = z.infer<
+  typeof slatesMessageProviderIdentifyResponse
+>;
+
+export type SlatesIdentifyRequests = SlatesMessageProviderIdentifyRequest;
+
+export type SlatesIdentifyResponses = SlatesMessageProviderIdentifyResponse;
+
+export let slatesIdentifyResponsesByMethod = {
+  'slates/provider.identify': slatesMessageProviderIdentifyResponse
+};
+
+export let slatesIdentifyRequestsByMethod = {
+  'slates/provider.identify': slatesMessageProviderIdentifyRequest
+};

package/src/messages/index.ts

@@ -0,0 +1,86 @@
+export * from './action';
+export * from './auth';
+export * from './config';
+export * from './controlFlow';
+export * from './identify';
+export * from './log';
+
+import { z } from 'zod';
+import {
+  SlatesActionRequests,
+  slatesActionRequestsByMethod,
+  SlatesActionResponses,
+  slatesActionResponsesByMethod
+} from './action';
+import {
+  SlatesAuthNotifications,
+  slatesAuthNotificationsByMethod,
+  SlatesAuthRequests,
+  slatesAuthRequestsByMethod,
+  SlatesAuthResponses,
+  slatesAuthResponsesByMethod
+} from './auth';
+import {
+  SlatesConfigNotifications,
+  slatesConfigNotificationsByMethod,
+  SlatesConfigRequests,
+  slatesConfigRequestsByMethod,
+  SlatesConfigResponses,
+  slatesConfigResponsesByMethod
+} from './config';
+import {
+  SlatesControlFlowNotifications,
+  slatesControlFlowNotificationsByMethod
+} from './controlFlow';
+import {
+  SlatesIdentifyRequests,
+  slatesIdentifyRequestsByMethod,
+  SlatesIdentifyResponses,
+  slatesIdentifyResponsesByMethod
+} from './identify';
+import { SlatesLogNotifications, slatesLogNotificationsByMethod } from './log';
+
+export type SlatesNotifications =
+  | SlatesAuthNotifications
+  | SlatesConfigNotifications
+  | SlatesControlFlowNotifications
+  | SlatesLogNotifications;
+
+export type SlatesRequests =
+  | SlatesActionRequests
+  | SlatesAuthRequests
+  | SlatesConfigRequests
+  | SlatesIdentifyRequests;
+
+export type SlatesResponses =
+  | SlatesActionResponses
+  | SlatesAuthResponses
+  | SlatesConfigResponses
+  | SlatesIdentifyResponses;
+
+export let slatesResponsesByMethod = {
+  ...slatesActionResponsesByMethod,
+  ...slatesAuthResponsesByMethod,
+  ...slatesConfigResponsesByMethod,
+  ...slatesIdentifyResponsesByMethod
+};
+
+export let slatesRequestsByMethod = {
+  ...slatesActionRequestsByMethod,
+  ...slatesAuthRequestsByMethod,
+  ...slatesConfigRequestsByMethod,
+  ...slatesIdentifyRequestsByMethod
+};
+
+export let slatesNotificationsByMethod = {
+  ...slatesAuthNotificationsByMethod,
+  ...slatesConfigNotificationsByMethod,
+  ...slatesControlFlowNotificationsByMethod,
+  ...slatesLogNotificationsByMethod
+};
+
+export type SlatesResponsesByMethod = {
+  [key in keyof typeof slatesResponsesByMethod]: z.infer<
+    (typeof slatesResponsesByMethod)[key]
+  >;
+};

package/src/messages/log.ts

@@ -0,0 +1,29 @@
+import z from 'zod';
+
+/**
+ * Send Log
+ */
+export let slatesMessageLogSendNotification = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/log.send'),
+  params: z.object({
+    type: z.union([
+      z.literal('info'),
+      z.literal('warning'),
+      z.literal('error'),
+      z.literal('progress')
+    ]),
+    timestamp: z.string(),
+    message: z.string()
+  })
+});
+
+export type SlatesMessageLogSendNotification = z.infer<
+  typeof slatesMessageLogSendNotification
+>;
+
+export type SlatesLogNotifications = SlatesMessageLogSendNotification;
+
+export let slatesLogNotificationsByMethod = {
+  'slates/log.send': slatesMessageLogSendNotification
+};

package/src/types/action.ts

@@ -0,0 +1,48 @@
+import z from 'zod';
+
+export let slatesActionBase = z.object({
+  id: z.string(),
+
+  name: z.string(),
+  description: z.string().optional(),
+  instructions: z.array(z.string()).optional(),
+  constraints: z.array(z.string()).optional(),
+  tags: z
+    .object({
+      destructive: z.boolean().optional(),
+      readOnly: z.boolean().optional()
+    })
+    .optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+
+  inputSchema: z.record(z.string(), z.any()),
+  outputSchema: z.record(z.string(), z.any())
+});
+
+export let slatesActionTool = slatesActionBase.extend({
+  type: z.literal('action.tool'),
+  capabilities: z.object({})
+});
+
+export let slatesActionTrigger = slatesActionBase.extend({
+  type: z.literal('action.trigger'),
+  capabilities: z.object({}),
+
+  invocation: z.union([
+    z.object({
+      type: z.literal('polling'),
+      intervalSeconds: z.number().min(15)
+    }),
+    z.object({
+      type: z.literal('webhook'),
+      autoRegistration: z.boolean(),
+      autoUnregistration: z.boolean()
+    })
+  ])
+});
+
+export let slatesAction = z.union([slatesActionTool, slatesActionTrigger]);
+
+export type SlatesAction = z.infer<typeof slatesAction>;
+export type SlatesActionTool = z.infer<typeof slatesActionTool>;
+export type SlatesActionTrigger = z.infer<typeof slatesActionTrigger>;

package/src/types/authMethod.ts

@@ -0,0 +1,35 @@
+import z from 'zod';
+
+export let slatesAuthenticationMethod = z.object({
+  id: z.string(),
+  name: z.string(),
+
+  type: z.union([
+    z.literal('auth.oauth'),
+    z.literal('auth.token'),
+    z.literal('auth.service_account'),
+    z.literal('auth.custom')
+  ]),
+
+  scopes: z
+    .array(
+      z.object({
+        id: z.string(),
+        title: z.string(),
+        description: z.string().optional()
+      })
+    )
+    .optional(),
+
+  inputSchema: z.record(z.string(), z.any()),
+  outputSchema: z.record(z.string(), z.any()),
+
+  capabilities: z.object({
+    getDefaultInput: z.object({ enabled: z.boolean() }).optional(),
+    handleChangedInput: z.object({ enabled: z.boolean() }).optional(),
+    handleTokenRefresh: z.object({ enabled: z.boolean() }).optional(),
+    getProfile: z.object({ enabled: z.boolean() }).optional()
+  })
+});
+
+export type SlateAuthenticationMethod = z.infer<typeof slatesAuthenticationMethod>;

package/src/types/index.ts

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

package/src/types/participant.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+
+export let slatesParticipant = z.object({
+  type: z.union([z.literal('consumer'), z.literal('hub')]),
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  metadata: z.record(z.string(), z.any()).optional()
+});
+
+export type SlatesParticipant = z.infer<typeof slatesParticipant>;

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@slates/tsconfig/base.json",
+  "exclude": ["dist"],
+  "compilerOptions": {
+    "outDir": "dist"
+  }
+}