@slates/proto 1.0.0-rc.1 → 1.0.0-rc.10

package/dist/index.module.js

@@ -0,0 +1,997 @@
+// src/handler/provider.ts
+import {
+  badRequestError,
+  isServiceError,
+  notFoundError,
+  validationError
+} from "@lowerdeck/error";
+
+// src/messages/action.ts
+import z5 from "zod";
+
+// src/types/action.ts
+import z from "zod";
+var slatesActionScopeClause = z.object({
+  OR: z.array(z.string()).min(1)
+});
+var slatesActionScopes = z.object({
+  AND: z.array(slatesActionScopeClause).min(1)
+});
+var 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(),
+  scopes: slatesActionScopes.optional(),
+  inputSchema: z.record(z.string(), z.any()),
+  outputSchema: z.record(z.string(), z.any())
+});
+var slatesActionTool = slatesActionBase.extend({
+  type: z.literal("action.tool"),
+  capabilities: z.object({})
+});
+var slatesActionTrigger = slatesActionBase.extend({
+  type: z.literal("action.trigger"),
+  capabilities: z.object({}),
+  invocation: z.union([
+    z.object({
+      type: z.literal("polling"),
+      intervalSeconds: z.number().min(60 * 10)
+    }),
+    z.object({
+      type: z.literal("webhook"),
+      autoRegistration: z.boolean(),
+      autoUnregistration: z.boolean()
+    })
+  ])
+});
+var slatesAction = z.union([slatesActionTool, slatesActionTrigger]);
+
+// src/types/authMethod.ts
+import z2 from "zod";
+var slatesAuthenticationMethod = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  type: z2.union([
+    z2.literal("auth.oauth"),
+    z2.literal("auth.token"),
+    z2.literal("auth.service_account"),
+    z2.literal("auth.custom")
+  ]),
+  scopes: z2.array(
+    z2.object({
+      id: z2.string(),
+      title: z2.string(),
+      description: z2.string().optional(),
+      defaultChecked: z2.boolean().optional()
+    })
+  ).optional(),
+  inputSchema: z2.record(z2.string(), z2.any()),
+  outputSchema: z2.record(z2.string(), z2.any()),
+  capabilities: z2.object({
+    getDefaultInput: z2.object({ enabled: z2.boolean() }).optional(),
+    handleChangedInput: z2.object({ enabled: z2.boolean() }).optional(),
+    handleTokenRefresh: z2.object({ enabled: z2.boolean() }).optional(),
+    getProfile: z2.object({ enabled: z2.boolean() }).optional()
+  }),
+  docs: z2.object({
+    oauthDocsLink: z2.string().optional(),
+    oauthScopesLink: z2.string().optional(),
+    tokenDocsLink: z2.string().optional(),
+    serviceAccountDocsLink: z2.string().optional(),
+    customAuthDocsLink: z2.string().optional()
+  }).optional()
+});
+
+// src/types/participant.ts
+import z3 from "zod";
+var slatesParticipant = z3.object({
+  type: z3.union([z3.literal("consumer"), z3.literal("hub")]),
+  id: z3.string(),
+  name: z3.string(),
+  description: z3.string().optional(),
+  metadata: z3.record(z3.string(), z3.any()).optional()
+});
+
+// src/messages/tracing.ts
+import z4 from "zod";
+var slatesRequestTraceTextBody = z4.object({
+  contentType: z4.string().optional(),
+  text: z4.string(),
+  truncated: z4.boolean().optional()
+});
+var slatesRequestTrace = z4.object({
+  startedAt: z4.string(),
+  durationMs: z4.number().nonnegative(),
+  request: z4.object({
+    method: z4.string(),
+    url: z4.string(),
+    headers: z4.record(z4.string(), z4.string()).optional(),
+    body: slatesRequestTraceTextBody.optional()
+  }),
+  response: z4.object({
+    status: z4.number(),
+    statusText: z4.string().optional(),
+    headers: z4.record(z4.string(), z4.string()).optional(),
+    body: slatesRequestTraceTextBody.optional()
+  }).optional(),
+  error: z4.object({
+    code: z4.string().optional(),
+    message: z4.string()
+  }).optional()
+});
+var withRequestTraces = (shape) => z4.object({
+  ...shape,
+  requestTraces: z4.array(slatesRequestTrace).optional()
+});
+
+// src/messages/action.ts
+var slatesMessageActionsListRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/actions.list"),
+  id: z5.string(),
+  params: z5.object({})
+});
+var slatesMessageActionsListResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: z5.object({
+    actions: z5.array(slatesAction)
+  })
+});
+var slatesMessageActionGetRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.get"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string()
+  })
+});
+var slatesMessageActionGetResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: z5.object({
+    action: slatesAction
+  })
+});
+var slatesMessageActionInvokeRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.tool.invoke"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    input: z5.record(z5.string(), z5.any())
+  })
+});
+var slatesMessageActionInvokeResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({
+    output: z5.record(z5.string(), z5.any()),
+    message: z5.string().optional(),
+    attachments: z5.array(
+      z5.object({
+        mimeType: z5.string().optional(),
+        content: z5.union([
+          z5.object({
+            type: z5.literal("url"),
+            url: z5.string()
+          }),
+          z5.object({
+            type: z5.literal("content"),
+            encoding: z5.union([z5.literal("base64"), z5.literal("utf-8")]),
+            content: z5.string()
+          })
+        ])
+      })
+    ).optional()
+  })
+});
+var slatesMessageActionTriggerEventMapRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.trigger.map_event"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    input: z5.record(z5.string(), z5.any())
+  })
+});
+var slatesMessageActionTriggerEventMapResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({
+    type: z5.string(),
+    id: z5.string(),
+    output: z5.record(z5.string(), z5.any())
+  })
+});
+var slatesMessageActionTriggerEventsPollRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.trigger.poll_events"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    state: z5.any().nullable()
+  })
+});
+var slatesMessageActionTriggerEventsPollResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({
+    inputs: z5.array(z5.record(z5.string(), z5.any())),
+    updatedState: z5.any().nullable().optional()
+  })
+});
+var slatesMessageActionTriggerWebhookHandleRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.trigger.webhook_handle"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    url: z5.string(),
+    method: z5.string(),
+    headers: z5.record(z5.string(), z5.string()),
+    body: z5.object({
+      encoding: z5.literal("base64"),
+      content: z5.string()
+    }).nullable(),
+    state: z5.any().nullable()
+  })
+});
+var slatesMessageActionTriggerWebhookHandleResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({
+    inputs: z5.array(z5.record(z5.string(), z5.any())),
+    updatedState: z5.any().nullable().optional()
+  })
+});
+var slatesMessageActionTriggerWebhookRegisterRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.trigger.webhook_register"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    webhookBaseUrl: z5.string()
+  })
+});
+var slatesMessageActionTriggerWebhookRegisterResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({
+    registrationDetails: z5.any(),
+    state: z5.any().optional()
+  })
+});
+var slatesMessageActionTriggerWebhookUnregisterRequest = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  method: z5.literal("slates/action.trigger.webhook_unregister"),
+  id: z5.string(),
+  params: z5.object({
+    actionId: z5.string(),
+    webhookBaseUrl: z5.string(),
+    registrationDetails: z5.any(),
+    state: z5.any().optional()
+  })
+});
+var slatesMessageActionTriggerWebhookUnregisterResponse = z5.object({
+  jsonrpc: z5.literal("2.0"),
+  id: z5.string(),
+  result: withRequestTraces({})
+});
+var 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
+};
+var 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
+};
+
+// src/messages/auth.ts
+import z6 from "zod";
+var slatesMessageSetAuthNotification = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.set"),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    output: z6.record(z6.string(), z6.any())
+  })
+});
+var slatesMessageAuthMethodsListRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.methods.list"),
+  id: z6.string(),
+  params: z6.object({})
+});
+var slatesMessageAuthMethodsListResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: z6.object({
+    authenticationMethods: z6.array(slatesAuthenticationMethod)
+  })
+});
+var slatesMessageAuthMethodGetRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.method.get"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string()
+  })
+});
+var slatesMessageAuthMethodGetResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: z6.object({
+    authenticationMethod: slatesAuthenticationMethod
+  })
+});
+var slatesMessageAuthInputChangedRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.input.changed"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    previousInput: z6.record(z6.string(), z6.any()).nullable(),
+    newInput: z6.record(z6.string(), z6.any())
+  })
+});
+var slatesMessageAuthInputChangedResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    input: z6.record(z6.string(), z6.any()).optional()
+  })
+});
+var slatesMessageAuthDefaultInputGetRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.input.get_default"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string()
+  })
+});
+var slatesMessageAuthDefaultInputGetResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    input: z6.record(z6.string(), z6.any())
+  })
+});
+var slatesMessageAuthAuthorizationUrlGetRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.authorization_url.get"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    redirectUri: z6.string(),
+    state: z6.string(),
+    input: z6.record(z6.string(), z6.any()),
+    clientId: z6.string(),
+    clientSecret: z6.string(),
+    scopes: z6.array(z6.string())
+  })
+});
+var slatesMessageAuthAuthorizationUrlGetResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    authorizationUrl: z6.string(),
+    input: z6.record(z6.string(), z6.any()).optional(),
+    callbackState: z6.record(z6.string(), z6.any()).optional()
+  })
+});
+var slatesMessageAuthAuthorizationCallbackHandleRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.authorization_callback.handle"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    code: z6.string(),
+    state: z6.string(),
+    redirectUri: z6.string(),
+    input: z6.record(z6.string(), z6.any()),
+    clientId: z6.string(),
+    clientSecret: z6.string(),
+    scopes: z6.array(z6.string()),
+    callbackParams: z6.record(z6.string(), z6.string()).optional(),
+    callbackState: z6.record(z6.string(), z6.any()).optional()
+  })
+});
+var slatesMessageAuthAuthorizationCallbackHandleResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    output: z6.record(z6.string(), z6.any()),
+    input: z6.record(z6.string(), z6.any()).optional(),
+    scopes: z6.array(z6.string()).optional()
+  })
+});
+var slatesMessageAuthTokenRefreshHandleRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.token_refresh.handle"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    output: z6.record(z6.string(), z6.any()),
+    input: z6.record(z6.string(), z6.any()),
+    clientId: z6.string(),
+    clientSecret: z6.string(),
+    scopes: z6.array(z6.string())
+  })
+});
+var slatesMessageAuthTokenRefreshHandleResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    output: z6.record(z6.string(), z6.any()),
+    input: z6.record(z6.string(), z6.any()).optional()
+  })
+});
+var slatesMessageAuthProfileGetRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.profile.get"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    output: z6.record(z6.string(), z6.any()),
+    input: z6.record(z6.string(), z6.any()),
+    scopes: z6.array(z6.string())
+  })
+});
+var slatesMessageAuthProfileGetResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    profile: z6.record(z6.string(), z6.any())
+  })
+});
+var slatesMessageAuthOutputGetRequest = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  method: z6.literal("slates/auth.output.get"),
+  id: z6.string(),
+  params: z6.object({
+    authenticationMethodId: z6.string(),
+    input: z6.record(z6.string(), z6.any())
+  })
+});
+var slatesMessageAuthOutputGetResponse = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.string(),
+  result: withRequestTraces({
+    output: z6.record(z6.string(), z6.any())
+  })
+});
+var 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
+};
+var 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
+};
+var slatesAuthNotificationsByMethod = {
+  "slates/auth.set": slatesMessageSetAuthNotification
+};
+
+// src/messages/config.ts
+import z7 from "zod";
+var slatesMessageSetConfigNotification = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  method: z7.literal("slates/config.set"),
+  params: z7.object({
+    config: z7.record(z7.string(), z7.any())
+  })
+});
+var slatesMessageConfigSchemaGetRequest = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  method: z7.literal("slates/config.schema.get"),
+  id: z7.string(),
+  params: z7.object({})
+});
+var slatesMessageConfigSchemaGetResponse = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  id: z7.string(),
+  result: z7.object({
+    schema: z7.record(z7.string(), z7.any())
+  })
+});
+var slatesMessageConfigChangedRequest = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  method: z7.literal("slates/config.changed"),
+  id: z7.string(),
+  params: z7.object({
+    previousConfig: z7.record(z7.string(), z7.any()).nullable(),
+    newConfig: z7.record(z7.string(), z7.any())
+  })
+});
+var slatesMessageConfigChangedResponse = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  id: z7.string(),
+  result: withRequestTraces({
+    success: z7.boolean(),
+    config: z7.record(z7.string(), z7.any()).optional(),
+    errors: z7.array(
+      z7.object({
+        code: z7.string(),
+        message: z7.string(),
+        path: z7.array(z7.string()).optional()
+      })
+    ).optional()
+  })
+});
+var slatesMessageConfigDefaultGetRequest = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  method: z7.literal("slates/config.get_default"),
+  id: z7.string(),
+  params: z7.object({})
+});
+var slatesMessageConfigDefaultGetResponse = z7.object({
+  jsonrpc: z7.literal("2.0"),
+  id: z7.string(),
+  result: withRequestTraces({
+    config: z7.record(z7.string(), z7.any()).nullable()
+  })
+});
+var slatesConfigResponsesByMethod = {
+  "slates/config.schema.get": slatesMessageConfigSchemaGetResponse,
+  "slates/config.get_default": slatesMessageConfigDefaultGetResponse,
+  "slates/config.changed": slatesMessageConfigChangedResponse
+};
+var slatesConfigRequestsByMethod = {
+  "slates/config.schema.get": slatesMessageConfigSchemaGetRequest,
+  "slates/config.get_default": slatesMessageConfigDefaultGetRequest,
+  "slates/config.changed": slatesMessageConfigChangedRequest
+};
+var slatesConfigNotificationsByMethod = {
+  "slates/config.set": slatesMessageSetConfigNotification
+};
+
+// src/messages/controlFlow.ts
+import z8 from "zod";
+
+// src/version.ts
+var SLATES_PROTOCOL_VERSION = "slates@2026-01-01";
+
+// src/messages/controlFlow.ts
+var slatesMessageHelloNotification = z8.object({
+  jsonrpc: z8.literal("2.0"),
+  method: z8.literal("slates/hello"),
+  params: z8.object({
+    protocol: z8.literal(SLATES_PROTOCOL_VERSION)
+  })
+});
+var slatesMessageSetParticipantsNotification = z8.object({
+  jsonrpc: z8.literal("2.0"),
+  method: z8.literal("slates/participant.set"),
+  params: z8.object({
+    participants: z8.array(slatesParticipant)
+  })
+});
+var slatesMessageSessionStartNotification = z8.object({
+  jsonrpc: z8.literal("2.0"),
+  method: z8.literal("slates/session.start"),
+  params: z8.object({
+    sessionId: z8.string(),
+    state: z8.record(z8.string(), z8.any())
+  })
+});
+var slatesControlFlowNotificationsByMethod = {
+  "slates/hello": slatesMessageHelloNotification,
+  "slates/participant.set": slatesMessageSetParticipantsNotification,
+  "slates/session.start": slatesMessageSessionStartNotification
+};
+
+// src/messages/identify.ts
+import z9 from "zod";
+var slatesMessageProviderIdentifyRequest = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  method: z9.literal("slates/provider.identify"),
+  id: z9.string(),
+  params: z9.object({})
+});
+var slatesMessageProviderIdentifyResponse = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  id: z9.string(),
+  result: z9.object({
+    protocol: z9.literal(SLATES_PROTOCOL_VERSION),
+    provider: z9.object({
+      type: z9.literal("provider"),
+      id: z9.string(),
+      name: z9.string(),
+      description: z9.string().optional(),
+      metadata: z9.record(z9.string(), z9.any()).optional()
+    })
+  })
+});
+var slatesIdentifyResponsesByMethod = {
+  "slates/provider.identify": slatesMessageProviderIdentifyResponse
+};
+var slatesIdentifyRequestsByMethod = {
+  "slates/provider.identify": slatesMessageProviderIdentifyRequest
+};
+
+// src/messages/index.ts
+var slatesResponsesByMethod = {
+  ...slatesActionResponsesByMethod,
+  ...slatesAuthResponsesByMethod,
+  ...slatesConfigResponsesByMethod,
+  ...slatesIdentifyResponsesByMethod
+};
+var slatesRequestsByMethod = {
+  ...slatesActionRequestsByMethod,
+  ...slatesAuthRequestsByMethod,
+  ...slatesConfigRequestsByMethod,
+  ...slatesIdentifyRequestsByMethod
+};
+var slatesNotificationsByMethod = {
+  ...slatesAuthNotificationsByMethod,
+  ...slatesConfigNotificationsByMethod,
+  ...slatesControlFlowNotificationsByMethod
+};
+
+// src/handler/provider.ts
+var SlatesProviderProtoHandlerManager = class {
+  #implMap = /* @__PURE__ */ new Map();
+  onNotification(method, handler) {
+    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, cb) {
+    let schema = slatesRequestsByMethod[method];
+    if (!schema) {
+      throw new Error(`No schema found for method: ${method}`);
+    }
+    this.#implMap.set(method, {
+      type: "request",
+      handler: cb,
+      schema
+    });
+  }
+  async _handleInput(input) {
+    try {
+      if (typeof input !== "object" || input === null) {
+        return {
+          jsonrpc: "2.0",
+          id: input.id,
+          error: toSlateErrorResponse(badRequestError({ message: "Invalid input" }))
+        };
+      }
+      if (input.jsonrpc !== "2.0") {
+        return {
+          jsonrpc: "2.0",
+          id: input.id,
+          error: toSlateErrorResponse(badRequestError({ message: "Invalid jsonrpc version" }))
+        };
+      }
+      let method = input.method;
+      if (typeof method !== "string") {
+        return {
+          jsonrpc: "2.0",
+          id: input.id,
+          error: toSlateErrorResponse(
+            badRequestError({ message: "Invalid or missing method" })
+          )
+        };
+      }
+      let impl = this.#implMap.get(input.method);
+      if (!impl) {
+        return {
+          jsonrpc: "2.0",
+          id: input.id,
+          error: toSlateErrorResponse(notFoundError("handler", input.method))
+        };
+      }
+      let parsed = impl.schema.safeParse(input);
+      if (!parsed.success) {
+        return {
+          jsonrpc: "2.0",
+          id: input.id,
+          error: toSlateErrorResponse(
+            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",
+        id: parsed.data.id,
+        result
+      };
+    } catch (err) {
+      if (!getSlateErrorResponse(err) && !getServiceErrorData(err)) {
+        console.error(err);
+      }
+      return {
+        jsonrpc: "2.0",
+        id: input.id,
+        error: toSlateErrorResponse(err, {
+          message: "Internal server error"
+        })
+      };
+    }
+  }
+  static async handleInput(manager, input) {
+    return manager._handleInput(input);
+  }
+};
+var createSlatesProviderProtoHandler = (cb) => ({
+  run: async () => {
+    let manager = new SlatesProviderProtoHandlerManager();
+    await cb(manager);
+    return manager;
+  }
+});
+var toSlateErrorResponse = (error, defaults = {}) => {
+  let slateError = getSlateErrorResponse(error);
+  if (slateError) return slateError;
+  let serviceError = getServiceErrorData(error);
+  if (serviceError) {
+    return mapServiceErrorToSlateErrorResponse(serviceError, defaults);
+  }
+  return mapUnknownErrorToSlateErrorResponse(error, defaults);
+};
+var SERVICE_ERROR_CODE_MAP = {
+  invalid_data: "input.invalid",
+  bad_request: "request.bad",
+  not_found: "resource.not_found",
+  unauthorized: "auth.required",
+  forbidden: "permission.denied",
+  invalid_version: "request.invalid_version",
+  conflict: "resource.conflict",
+  gone: "resource.gone",
+  payment_required: "payment.required",
+  precondition_failed: "request.precondition_failed",
+  not_acceptable: "request.not_acceptable",
+  not_implemented: "operation.not_implemented",
+  too_many_requests: "request.rate_limited",
+  timeout: "internal.timeout",
+  internal_server_error: "internal.unexpected"
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStructuredValue = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isSlateErrorPayload = (value) => isRecord(value) && typeof value.code === "string" && typeof value.message === "string" && typeof value.kind === "string";
+var isServiceErrorData = (value) => isRecord(value) && typeof value.status === "number" && typeof value.code === "string" && typeof value.message === "string" && !("config" in value) && !("request" in value) && !("response" in value) && !("isAxiosError" in value);
+var getSlateErrorResponse = (error) => {
+  if (isStructuredValue(error) && "name" in error && typeof error.name === "string" && error.name.startsWith("SlateError") && "toResponse" in error && typeof error.toResponse === "function") {
+    let response = error.toResponse();
+    return isSlateErrorPayload(response) ? response : null;
+  }
+  if (isSlateErrorPayload(error)) return error;
+  if (isStructuredValue(error) && "data" in error && isSlateErrorPayload(error.data)) {
+    return error.data;
+  }
+  return null;
+};
+var getServiceErrorData = (error) => {
+  if (isServiceError(error) && isServiceErrorData(error.data)) {
+    return error.data;
+  }
+  if (isServiceErrorData(error)) return error;
+  if (isStructuredValue(error) && "data" in error && isServiceErrorData(error.data)) {
+    return error.data;
+  }
+  if (isStructuredValue(error) && "toResponse" in error && typeof error.toResponse === "function") {
+    let response = error.toResponse();
+    if (isServiceErrorData(response)) return response;
+  }
+  return null;
+};
+var mapKind = (code) => {
+  if (code.startsWith("declaration.")) return "declaration";
+  if (code.startsWith("input.")) return "validation";
+  if (code.startsWith("request.")) return "request";
+  if (code.startsWith("config.")) return "config";
+  if (code.startsWith("auth.") || code.startsWith("permission.")) return "auth";
+  if (code.startsWith("resource.")) return "resource";
+  if (code.startsWith("payment.")) return "payment";
+  if (code.startsWith("transport.")) return "transport";
+  if (code.startsWith("upstream.")) return "upstream";
+  return "internal";
+};
+var mapRetryable = (code) => code === "request.rate_limited" || code === "upstream.rate_limited" || code === "upstream.timeout" || code === "upstream.network_error" || code === "upstream.unavailable" || code === "upstream.error" || code === "transport.invoke_failed" || code === "internal.timeout";
+var mapServiceErrorCode = (code, status) => {
+  if (SERVICE_ERROR_CODE_MAP[code]) return SERVICE_ERROR_CODE_MAP[code];
+  if (status === 400) return "request.bad";
+  if (status === 401) return "auth.required";
+  if (status === 402) return "payment.required";
+  if (status === 403) return "permission.denied";
+  if (status === 404) return "resource.not_found";
+  if (status === 406) return "request.not_acceptable";
+  if (status === 409) return "resource.conflict";
+  if (status === 410) return "resource.gone";
+  if (status === 412) return "request.precondition_failed";
+  if (status === 429) return "request.rate_limited";
+  if (status === 501) return "operation.not_implemented";
+  if (status === 504) return "internal.timeout";
+  if (status && status >= 500) return "internal.unexpected";
+  return "internal.unexpected";
+};
+var mapIssues = (errors) => {
+  if (!Array.isArray(errors)) return void 0;
+  let issues = errors.map((error) => {
+    if (!isRecord(error)) {
+      return { message: String(error) };
+    }
+    return {
+      ...error,
+      path: Array.isArray(error.path) ? error.path.map((entry) => String(entry)) : void 0,
+      code: typeof error.code === "string" ? error.code : void 0,
+      message: typeof error.message === "string" ? error.message : "Validation issue"
+    };
+  });
+  return issues.length > 0 ? issues : void 0;
+};
+var mapServiceErrorToSlateErrorResponse = (error, defaults = {}) => {
+  let code = defaults.code ?? mapServiceErrorCode(error.code, error.status);
+  let extraEntries = Object.entries(error).filter(
+    ([key]) => ![
+      "status",
+      "code",
+      "message",
+      "errors",
+      "hint",
+      "description",
+      "reason",
+      "object",
+      "ok"
+    ].includes(key)
+  );
+  return {
+    code,
+    kind: mapKind(code),
+    message: error.message,
+    retryable: mapRetryable(code),
+    status: error.status,
+    ...mapIssues(error.errors) ? { issues: mapIssues(error.errors) } : {},
+    baggage: {
+      serviceError: {
+        code: error.code,
+        status: error.status,
+        hint: error.hint,
+        description: error.description,
+        reason: error.reason
+      },
+      ...extraEntries.length > 0 ? { serviceErrorData: Object.fromEntries(extraEntries) } : {}
+    }
+  };
+};
+var mapUnknownErrorToSlateErrorResponse = (error, defaults = {}) => ({
+  code: defaults.code ?? "internal.unexpected",
+  kind: "internal",
+  message: defaults.message ?? (error instanceof Error ? error.message : "An unexpected internal error occurred."),
+  retryable: false,
+  status: 500,
+  ...error instanceof Error ? {
+    baggage: {
+      originalName: error.name
+    }
+  } : {}
+});
+export {
+  SLATES_PROTOCOL_VERSION,
+  SlatesProviderProtoHandlerManager,
+  createSlatesProviderProtoHandler,
+  slatesAction,
+  slatesActionBase,
+  slatesActionRequestsByMethod,
+  slatesActionResponsesByMethod,
+  slatesActionScopeClause,
+  slatesActionScopes,
+  slatesActionTool,
+  slatesActionTrigger,
+  slatesAuthNotificationsByMethod,
+  slatesAuthRequestsByMethod,
+  slatesAuthResponsesByMethod,
+  slatesAuthenticationMethod,
+  slatesConfigNotificationsByMethod,
+  slatesConfigRequestsByMethod,
+  slatesConfigResponsesByMethod,
+  slatesControlFlowNotificationsByMethod,
+  slatesIdentifyRequestsByMethod,
+  slatesIdentifyResponsesByMethod,
+  slatesMessageActionGetRequest,
+  slatesMessageActionGetResponse,
+  slatesMessageActionInvokeRequest,
+  slatesMessageActionInvokeResponse,
+  slatesMessageActionTriggerEventMapRequest,
+  slatesMessageActionTriggerEventMapResponse,
+  slatesMessageActionTriggerEventsPollRequest,
+  slatesMessageActionTriggerEventsPollResponse,
+  slatesMessageActionTriggerWebhookHandleRequest,
+  slatesMessageActionTriggerWebhookHandleResponse,
+  slatesMessageActionTriggerWebhookRegisterRequest,
+  slatesMessageActionTriggerWebhookRegisterResponse,
+  slatesMessageActionTriggerWebhookUnregisterRequest,
+  slatesMessageActionTriggerWebhookUnregisterResponse,
+  slatesMessageActionsListRequest,
+  slatesMessageActionsListResponse,
+  slatesMessageAuthAuthorizationCallbackHandleRequest,
+  slatesMessageAuthAuthorizationCallbackHandleResponse,
+  slatesMessageAuthAuthorizationUrlGetRequest,
+  slatesMessageAuthAuthorizationUrlGetResponse,
+  slatesMessageAuthDefaultInputGetRequest,
+  slatesMessageAuthDefaultInputGetResponse,
+  slatesMessageAuthInputChangedRequest,
+  slatesMessageAuthInputChangedResponse,
+  slatesMessageAuthMethodGetRequest,
+  slatesMessageAuthMethodGetResponse,
+  slatesMessageAuthMethodsListRequest,
+  slatesMessageAuthMethodsListResponse,
+  slatesMessageAuthOutputGetRequest,
+  slatesMessageAuthOutputGetResponse,
+  slatesMessageAuthProfileGetRequest,
+  slatesMessageAuthProfileGetResponse,
+  slatesMessageAuthTokenRefreshHandleRequest,
+  slatesMessageAuthTokenRefreshHandleResponse,
+  slatesMessageConfigChangedRequest,
+  slatesMessageConfigChangedResponse,
+  slatesMessageConfigDefaultGetRequest,
+  slatesMessageConfigDefaultGetResponse,
+  slatesMessageConfigSchemaGetRequest,
+  slatesMessageConfigSchemaGetResponse,
+  slatesMessageHelloNotification,
+  slatesMessageProviderIdentifyRequest,
+  slatesMessageProviderIdentifyResponse,
+  slatesMessageSessionStartNotification,
+  slatesMessageSetAuthNotification,
+  slatesMessageSetConfigNotification,
+  slatesMessageSetParticipantsNotification,
+  slatesNotificationsByMethod,
+  slatesParticipant,
+  slatesRequestTrace,
+  slatesRequestTraceTextBody,
+  slatesRequestsByMethod,
+  slatesResponsesByMethod,
+  withRequestTraces
+};