@slates/proto 1.0.0-rc.25 → 1.0.0-rc.27

package/dist/index.module.js

@@ -7,7 +7,7 @@ import {
 } from "@lowerdeck/error";
 
 // src/messages/action.ts
-import z8 from "zod";
+import z9 from "zod";
 
 // src/types/action.ts
 import z from "zod";
@@ -93,7 +93,8 @@ var slatesAuthenticationMethod = z3.object({
     getDefaultInput: z3.object({ enabled: z3.boolean() }).optional(),
     handleChangedInput: z3.object({ enabled: z3.boolean() }).optional(),
     handleTokenRefresh: z3.object({ enabled: z3.boolean() }).optional(),
-    getProfile: z3.object({ enabled: z3.boolean() }).optional()
+    getProfile: z3.object({ enabled: z3.boolean() }).optional(),
+    adminSetup: z3.object({ enabled: z3.boolean(), required: z3.boolean().optional() }).optional()
   }),
   docs: z3.array(
     z3.object({
@@ -110,196 +111,232 @@ var slatesAuthenticationMethod = z3.object({
   )
 });
 
-// src/types/participant.ts
+// src/types/error.ts
+import z5 from "zod";
+
+// src/messages/tracing.ts
 import z4 from "zod";
-var slatesParticipant = z4.object({
-  type: z4.union([z4.literal("consumer"), z4.literal("hub")]),
-  id: z4.string(),
-  name: z4.string(),
-  description: z4.string().optional(),
-  metadata: z4.record(z4.string(), z4.any()).optional()
+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/types/error.ts
+var slatesErrorResponse = z5.looseObject({
+  code: z5.string(),
+  kind: z5.string(),
+  message: z5.string(),
+  retryable: z5.boolean().optional(),
+  status: z5.number().optional(),
+  issues: z5.array(
+    z5.looseObject({
+      path: z5.array(z5.string()).optional(),
+      code: z5.string().optional(),
+      message: z5.string()
+    })
+  ).optional(),
+  provider: z5.looseObject({
+    key: z5.string().optional(),
+    service: z5.string().optional(),
+    operation: z5.string().optional()
+  }).optional(),
+  upstream: z5.looseObject({
+    status: z5.number().optional(),
+    code: z5.string().optional(),
+    type: z5.string().optional(),
+    requestId: z5.string().optional(),
+    method: z5.string().optional(),
+    url: z5.string().optional()
+  }).optional(),
+  // The upstream API's own error code, next to the normalized protocol `code`.
+  upstreamCode: z5.string().optional(),
+  baggage: z5.record(z5.string(), z5.unknown()).optional(),
+  requestTraces: z5.array(slatesRequestTrace).optional()
+});
+
+// src/types/participant.ts
+import z6 from "zod";
+var slatesParticipant = z6.object({
+  type: z6.union([z6.literal("consumer"), z6.literal("hub")]),
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string().optional(),
+  metadata: z6.record(z6.string(), z6.any()).optional()
 });
 
 // src/types/toolCategory.ts
-import z5 from "zod";
-var slatesToolCategory = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  description: z5.string().optional(),
-  imageUrl: z5.string().optional()
+import z7 from "zod";
+var slatesToolCategory = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  description: z7.string().optional(),
+  imageUrl: z7.string().optional()
 });
 
 // src/types/triggerGroup.ts
-import z6 from "zod";
-var slatesTriggerRoutingMatcher = z6.record(z6.string(), z6.any());
-var slatesTriggerGroupInvocation = z6.union([
-  z6.object({
-    type: z6.literal("polling"),
-    intervalSeconds: z6.number().min(60 * 10)
+import z8 from "zod";
+var slatesTriggerRoutingMatcher = z8.record(z8.string(), z8.any());
+var slatesTriggerGroupInvocation = z8.union([
+  z8.object({
+    type: z8.literal("polling"),
+    intervalSeconds: z8.number().min(60 * 10)
   }),
-  z6.object({
-    type: z6.literal("gateway")
+  z8.object({
+    type: z8.literal("gateway")
   }),
-  z6.object({
-    type: z6.literal("webhook"),
-    registration: z6.union([
-      z6.object({
-        mode: z6.literal("auto")
+  z8.object({
+    type: z8.literal("webhook"),
+    registration: z8.union([
+      z8.object({
+        mode: z8.literal("auto")
       }),
-      z6.object({
-        mode: z6.literal("manual"),
-        userConfigSchema: z6.record(z6.string(), z6.any()),
-        fullConfigSchema: z6.record(z6.string(), z6.any())
+      z8.object({
+        mode: z8.literal("manual"),
+        userConfigSchema: z8.record(z8.string(), z8.any()),
+        fullConfigSchema: z8.record(z8.string(), z8.any())
       })
     ])
   })
 ]);
-var slatesTriggerGroup = z6.object({
-  id: z6.string(),
-  name: z6.string(),
-  description: z6.string().optional(),
-  metadata: z6.record(z6.string(), z6.any()).optional(),
+var slatesTriggerGroup = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  description: z8.string().optional(),
+  metadata: z8.record(z8.string(), z8.any()).optional(),
   invocation: slatesTriggerGroupInvocation
 });
-var slatesWebhookTargetOwnership = z6.enum(["single_user", "multi_user"]);
-var slatesWebhookTarget = z6.object({
-  webhookTargetIdentifier: z6.string(),
-  name: z6.string(),
-  description: z6.string().optional(),
-  metadata: z6.record(z6.string(), z6.any()),
-  webhookTargetPayload: z6.any(),
+var slatesWebhookTargetOwnership = z8.enum(["single_user", "multi_user"]);
+var slatesWebhookTarget = z8.object({
+  webhookTargetIdentifier: z8.string(),
+  name: z8.string(),
+  description: z8.string().optional(),
+  metadata: z8.record(z8.string(), z8.any()),
+  webhookTargetPayload: z8.any(),
   targetOwnership: slatesWebhookTargetOwnership
 });
 
-// src/messages/tracing.ts
-import z7 from "zod";
-var slatesRequestTraceTextBody = z7.object({
-  contentType: z7.string().optional(),
-  text: z7.string(),
-  truncated: z7.boolean().optional()
-});
-var slatesRequestTrace = z7.object({
-  startedAt: z7.string(),
-  durationMs: z7.number().nonnegative(),
-  request: z7.object({
-    method: z7.string(),
-    url: z7.string(),
-    headers: z7.record(z7.string(), z7.string()).optional(),
-    body: slatesRequestTraceTextBody.optional()
-  }),
-  response: z7.object({
-    status: z7.number(),
-    statusText: z7.string().optional(),
-    headers: z7.record(z7.string(), z7.string()).optional(),
-    body: slatesRequestTraceTextBody.optional()
-  }).optional(),
-  error: z7.object({
-    code: z7.string().optional(),
-    message: z7.string()
-  }).optional()
-});
-var withRequestTraces = (shape) => z7.object({
-  ...shape,
-  requestTraces: z7.array(slatesRequestTrace).optional()
-});
-
 // src/messages/action.ts
-var slatesWebhookHttpResponse = z8.object({
-  status: z8.number().int().min(100).max(599),
-  headers: z8.record(z8.string(), z8.string()),
-  body: z8.object({
-    encoding: z8.literal("base64"),
-    content: z8.string()
+var slatesWebhookHttpResponse = z9.object({
+  status: z9.number().int().min(100).max(599),
+  headers: z9.record(z9.string(), z9.string()),
+  body: z9.object({
+    encoding: z9.literal("base64"),
+    content: z9.string()
   }).nullable()
 });
-var slatesMessageActionsListRequest = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  method: z8.literal("slates/actions.list"),
-  id: z8.string(),
-  params: z8.object({
-    includeAdapterActions: z8.optional(z8.nullable(z8.boolean()))
+var slatesMessageActionsListRequest = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  method: z9.literal("slates/actions.list"),
+  id: z9.string(),
+  params: z9.object({
+    includeAdapterActions: z9.optional(z9.nullable(z9.boolean()))
   })
 });
-var slatesMessageActionsListResponse = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  id: z8.string(),
-  result: z8.object({
-    actions: z8.array(slatesAction)
+var slatesMessageActionsListResponse = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  id: z9.string(),
+  result: z9.object({
+    actions: z9.array(slatesAction)
   })
 });
-var slatesMessageActionGetRequest = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  method: z8.literal("slates/action.get"),
-  id: z8.string(),
-  params: z8.object({
-    actionId: z8.string()
+var slatesMessageActionGetRequest = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  method: z9.literal("slates/action.get"),
+  id: z9.string(),
+  params: z9.object({
+    actionId: z9.string()
   })
 });
-var slatesMessageActionGetResponse = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  id: z8.string(),
-  result: z8.object({
+var slatesMessageActionGetResponse = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  id: z9.string(),
+  result: z9.object({
     action: slatesAction
   })
 });
-var slatesMessageActionInvokeRequest = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  method: z8.literal("slates/action.tool.invoke"),
-  id: z8.string(),
-  params: z8.object({
-    actionId: z8.string(),
-    input: z8.record(z8.string(), z8.any())
+var slatesMessageActionInvokeRequest = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  method: z9.literal("slates/action.tool.invoke"),
+  id: z9.string(),
+  params: z9.object({
+    actionId: z9.string(),
+    input: z9.record(z9.string(), z9.any())
   })
 });
-var slatesMessageActionInvokeResponse = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  id: z8.string(),
+var slatesMessageActionInvokeResponse = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  id: z9.string(),
   result: withRequestTraces({
-    output: z8.record(z8.string(), z8.any()),
-    message: z8.string().optional(),
-    attachments: z8.array(
-      z8.object({
-        mimeType: z8.string().optional(),
-        attachmentHash: z8.string().optional(),
-        content: z8.union([
-          z8.object({
-            type: z8.literal("url"),
-            url: z8.string(),
-            headers: z8.record(z8.string(), z8.string()).optional(),
-            query: z8.record(z8.string(), z8.string()).optional(),
-            refreshReference: z8.unknown().optional(),
-            refreshAt: z8.string().optional()
+    output: z9.record(z9.string(), z9.any()),
+    message: z9.string().optional(),
+    attachments: z9.array(
+      z9.object({
+        mimeType: z9.string().optional(),
+        attachmentHash: z9.string().optional(),
+        content: z9.union([
+          z9.object({
+            type: z9.literal("url"),
+            url: z9.string(),
+            headers: z9.record(z9.string(), z9.string()).optional(),
+            query: z9.record(z9.string(), z9.string()).optional(),
+            refreshReference: z9.unknown().optional(),
+            refreshAt: z9.string().optional()
           }),
-          z8.object({
-            type: z8.literal("content"),
-            encoding: z8.union([z8.literal("base64"), z8.literal("utf-8")]),
-            content: z8.string()
+          z9.object({
+            type: z9.literal("content"),
+            encoding: z9.union([z9.literal("base64"), z9.literal("utf-8")]),
+            content: z9.string()
           }),
-          z8.object({
-            type: z8.literal("upload_reference"),
-            referenceId: z8.string()
+          z9.object({
+            type: z9.literal("upload_reference"),
+            referenceId: z9.string()
           })
         ])
       })
     ).optional()
   })
 });
-var slatesMessageActionTriggerEventMapRequest = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  method: z8.literal("slates/action.trigger.map_event"),
-  id: z8.string(),
-  params: z8.object({
-    actionId: z8.string(),
-    input: z8.record(z8.string(), z8.any())
+var slatesMessageActionTriggerEventMapRequest = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  method: z9.literal("slates/action.trigger.map_event"),
+  id: z9.string(),
+  params: z9.object({
+    actionId: z9.string(),
+    input: z9.record(z9.string(), z9.any())
   })
 });
-var slatesMessageActionTriggerEventMapResponse = z8.object({
-  jsonrpc: z8.literal("2.0"),
-  id: z8.string(),
+var slatesMessageActionTriggerEventMapResponse = z9.object({
+  jsonrpc: z9.literal("2.0"),
+  id: z9.string(),
   result: withRequestTraces({
-    type: z8.string(),
-    id: z8.string(),
-    output: z8.record(z8.string(), z8.any())
+    type: z9.string(),
+    id: z9.string(),
+    output: z9.record(z9.string(), z9.any())
   })
 });
 var slatesActionResponsesByMethod = {
@@ -316,34 +353,34 @@ var slatesActionRequestsByMethod = {
 };
 
 // src/messages/adapter.ts
-import z9 from "zod";
-var slatesMessageAdaptersListRequest = z9.object({
-  jsonrpc: z9.literal("2.0"),
-  method: z9.literal("slates/adapters.list"),
-  id: z9.string(),
-  params: z9.object({
-    includeAdapters: z9.optional(z9.nullable(z9.boolean()))
+import z10 from "zod";
+var slatesMessageAdaptersListRequest = z10.object({
+  jsonrpc: z10.literal("2.0"),
+  method: z10.literal("slates/adapters.list"),
+  id: z10.string(),
+  params: z10.object({
+    includeAdapters: z10.optional(z10.nullable(z10.boolean()))
   })
 });
-var slatesMessageAdaptersListResponse = z9.object({
-  jsonrpc: z9.literal("2.0"),
-  id: z9.string(),
-  result: z9.object({
-    adapters: z9.array(slatesAdapter)
+var slatesMessageAdaptersListResponse = z10.object({
+  jsonrpc: z10.literal("2.0"),
+  id: z10.string(),
+  result: z10.object({
+    adapters: z10.array(slatesAdapter)
   })
 });
-var slatesMessageAdapterGetRequest = z9.object({
-  jsonrpc: z9.literal("2.0"),
-  method: z9.literal("slates/adapter.get"),
-  id: z9.string(),
-  params: z9.object({
-    adapterId: z9.string()
+var slatesMessageAdapterGetRequest = z10.object({
+  jsonrpc: z10.literal("2.0"),
+  method: z10.literal("slates/adapter.get"),
+  id: z10.string(),
+  params: z10.object({
+    adapterId: z10.string()
   })
 });
-var slatesMessageAdapterGetResponse = z9.object({
-  jsonrpc: z9.literal("2.0"),
-  id: z9.string(),
-  result: z9.object({
+var slatesMessageAdapterGetResponse = z10.object({
+  jsonrpc: z10.literal("2.0"),
+  id: z10.string(),
+  result: z10.object({
     adapter: slatesAdapter
   })
 });
@@ -357,180 +394,219 @@ var slatesAdapterRequestsByMethod = {
 };
 
 // src/messages/auth.ts
-import z10 from "zod";
-var slatesMessageSetAuthNotification = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.set"),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    output: z10.record(z10.string(), z10.any())
+import z11 from "zod";
+var slatesMessageSetAuthNotification = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.set"),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    output: z11.record(z11.string(), z11.any())
   })
 });
-var slatesMessageAuthMethodsListRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.methods.list"),
-  id: z10.string(),
-  params: z10.object({})
+var slatesMessageAuthMethodsListRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.methods.list"),
+  id: z11.string(),
+  params: z11.object({})
 });
-var slatesMessageAuthMethodsListResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
-  result: z10.object({
-    authenticationMethods: z10.array(slatesAuthenticationMethod)
+var slatesMessageAuthMethodsListResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
+  result: z11.object({
+    authenticationMethods: z11.array(slatesAuthenticationMethod)
   })
 });
-var slatesMessageAuthMethodGetRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.method.get"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string()
+var slatesMessageAuthMethodGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.method.get"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string()
   })
 });
-var slatesMessageAuthMethodGetResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
-  result: z10.object({
+var slatesMessageAuthMethodGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
+  result: z11.object({
     authenticationMethod: slatesAuthenticationMethod
   })
 });
-var slatesMessageAuthInputChangedRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.input.changed"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    previousInput: z10.record(z10.string(), z10.any()).nullable(),
-    newInput: z10.record(z10.string(), z10.any())
+var slatesMessageAuthInputChangedRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.input.changed"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    previousInput: z11.record(z11.string(), z11.any()).nullable(),
+    newInput: z11.record(z11.string(), z11.any())
   })
 });
-var slatesMessageAuthInputChangedResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthInputChangedResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    input: z10.record(z10.string(), z10.any()).optional()
+    input: z11.record(z11.string(), z11.any()).optional()
   })
 });
-var slatesMessageAuthDefaultInputGetRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.input.get_default"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string()
+var slatesMessageAuthDefaultInputGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.input.get_default"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string()
   })
 });
-var slatesMessageAuthDefaultInputGetResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthDefaultInputGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    input: z10.record(z10.string(), z10.any())
+    input: z11.record(z11.string(), z11.any())
   })
 });
-var slatesMessageAuthAuthorizationUrlGetRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.authorization_url.get"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    redirectUri: z10.string(),
-    state: z10.string(),
-    input: z10.record(z10.string(), z10.any()),
-    clientId: z10.string(),
-    clientSecret: z10.string(),
-    scopes: z10.array(z10.string())
+var slatesMessageAuthAuthorizationUrlGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.authorization_url.get"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    redirectUri: z11.string(),
+    state: z11.string(),
+    input: z11.record(z11.string(), z11.any()),
+    clientId: z11.string(),
+    clientSecret: z11.string(),
+    scopes: z11.array(z11.string())
   })
 });
-var slatesMessageAuthAuthorizationUrlGetResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthAuthorizationUrlGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    authorizationUrl: z10.string(),
-    input: z10.record(z10.string(), z10.any()).optional(),
-    callbackState: z10.record(z10.string(), z10.any()).optional()
+    authorizationUrl: z11.string(),
+    input: z11.record(z11.string(), z11.any()).optional(),
+    callbackState: z11.record(z11.string(), z11.any()).optional()
   })
 });
-var slatesMessageAuthAuthorizationCallbackHandleRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.authorization_callback.handle"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    code: z10.string(),
-    state: z10.string(),
-    redirectUri: z10.string(),
-    input: z10.record(z10.string(), z10.any()),
-    clientId: z10.string(),
-    clientSecret: z10.string(),
-    scopes: z10.array(z10.string()),
-    callbackParams: z10.record(z10.string(), z10.string()).optional(),
-    callbackState: z10.record(z10.string(), z10.any()).optional()
-  })
-});
-var slatesMessageAuthAuthorizationCallbackHandleResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthAuthorizationCallbackHandleRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.authorization_callback.handle"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    code: z11.string(),
+    state: z11.string(),
+    redirectUri: z11.string(),
+    input: z11.record(z11.string(), z11.any()),
+    clientId: z11.string(),
+    clientSecret: z11.string(),
+    scopes: z11.array(z11.string()),
+    callbackParams: z11.record(z11.string(), z11.string()).optional(),
+    callbackState: z11.record(z11.string(), z11.any()).optional()
+  })
+});
+var slatesMessageAuthAuthorizationCallbackHandleResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    output: z10.record(z10.string(), z10.any()),
-    input: z10.record(z10.string(), z10.any()).optional(),
-    scopes: z10.array(z10.string()).optional(),
-    routingMatchers: z10.array(slatesTriggerRoutingMatcher).optional()
+    output: z11.record(z11.string(), z11.any()),
+    input: z11.record(z11.string(), z11.any()).optional(),
+    scopes: z11.array(z11.string()).optional(),
+    routingMatchers: z11.array(slatesTriggerRoutingMatcher).optional()
   })
 });
-var slatesMessageAuthTokenRefreshHandleRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.token_refresh.handle"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    output: z10.record(z10.string(), z10.any()),
-    input: z10.record(z10.string(), z10.any()),
-    clientId: z10.string(),
-    clientSecret: z10.string(),
-    scopes: z10.array(z10.string())
+var slatesMessageAuthAdminAuthorizationUrlGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.admin_authorization_url.get"),
+  id: z11.string(),
+  params: slatesMessageAuthAuthorizationUrlGetRequest.shape.params
+});
+var slatesMessageAuthAdminAuthorizationUrlGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
+  result: withRequestTraces({
+    authorizationUrl: z11.string(),
+    input: z11.record(z11.string(), z11.any()).optional(),
+    callbackState: z11.record(z11.string(), z11.any()).optional()
   })
 });
-var slatesMessageAuthTokenRefreshHandleResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthAdminCallbackHandleRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.admin_callback.handle"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    code: z11.string().optional(),
+    state: z11.string(),
+    redirectUri: z11.string(),
+    input: z11.record(z11.string(), z11.any()),
+    clientId: z11.string(),
+    clientSecret: z11.string(),
+    scopes: z11.array(z11.string()),
+    callbackParams: z11.record(z11.string(), z11.string()).optional(),
+    callbackState: z11.record(z11.string(), z11.any()).optional()
+  })
+});
+var slatesMessageAuthAdminCallbackHandleResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    output: z10.record(z10.string(), z10.any()),
-    input: z10.record(z10.string(), z10.any()).optional(),
-    routingMatchers: z10.array(slatesTriggerRoutingMatcher).optional()
+    instructions: z11.string().optional()
   })
 });
-var slatesMessageAuthProfileGetRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.profile.get"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    output: z10.record(z10.string(), z10.any()),
-    input: z10.record(z10.string(), z10.any()),
-    scopes: z10.array(z10.string())
+var slatesMessageAuthTokenRefreshHandleRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.token_refresh.handle"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    output: z11.record(z11.string(), z11.any()),
+    input: z11.record(z11.string(), z11.any()),
+    clientId: z11.string(),
+    clientSecret: z11.string(),
+    scopes: z11.array(z11.string())
   })
 });
-var slatesMessageAuthProfileGetResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthTokenRefreshHandleResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    profile: z10.record(z10.string(), z10.any())
+    output: z11.record(z11.string(), z11.any()),
+    input: z11.record(z11.string(), z11.any()).optional(),
+    routingMatchers: z11.array(slatesTriggerRoutingMatcher).optional()
   })
 });
-var slatesMessageAuthOutputGetRequest = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  method: z10.literal("slates/auth.output.get"),
-  id: z10.string(),
-  params: z10.object({
-    authenticationMethodId: z10.string(),
-    input: z10.record(z10.string(), z10.any())
+var slatesMessageAuthProfileGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.profile.get"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    output: z11.record(z11.string(), z11.any()),
+    input: z11.record(z11.string(), z11.any()),
+    scopes: z11.array(z11.string())
   })
 });
-var slatesMessageAuthOutputGetResponse = z10.object({
-  jsonrpc: z10.literal("2.0"),
-  id: z10.string(),
+var slatesMessageAuthProfileGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
+  result: withRequestTraces({
+    profile: z11.record(z11.string(), z11.any())
+  })
+});
+var slatesMessageAuthOutputGetRequest = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  method: z11.literal("slates/auth.output.get"),
+  id: z11.string(),
+  params: z11.object({
+    authenticationMethodId: z11.string(),
+    input: z11.record(z11.string(), z11.any())
+  })
+});
+var slatesMessageAuthOutputGetResponse = z11.object({
+  jsonrpc: z11.literal("2.0"),
+  id: z11.string(),
   result: withRequestTraces({
-    output: z10.record(z10.string(), z10.any()),
-    scopes: z10.array(z10.string()).optional()
+    output: z11.record(z11.string(), z11.any()),
+    scopes: z11.array(z11.string()).optional()
   })
 });
 var slatesAuthResponsesByMethod = {
@@ -540,6 +616,8 @@ var slatesAuthResponsesByMethod = {
   "slates/auth.input.get_default": slatesMessageAuthDefaultInputGetResponse,
   "slates/auth.authorization_url.get": slatesMessageAuthAuthorizationUrlGetResponse,
   "slates/auth.authorization_callback.handle": slatesMessageAuthAuthorizationCallbackHandleResponse,
+  "slates/auth.admin_authorization_url.get": slatesMessageAuthAdminAuthorizationUrlGetResponse,
+  "slates/auth.admin_callback.handle": slatesMessageAuthAdminCallbackHandleResponse,
   "slates/auth.token_refresh.handle": slatesMessageAuthTokenRefreshHandleResponse,
   "slates/auth.profile.get": slatesMessageAuthProfileGetResponse,
   "slates/auth.output.get": slatesMessageAuthOutputGetResponse
@@ -551,6 +629,8 @@ var slatesAuthRequestsByMethod = {
   "slates/auth.input.get_default": slatesMessageAuthDefaultInputGetRequest,
   "slates/auth.authorization_url.get": slatesMessageAuthAuthorizationUrlGetRequest,
   "slates/auth.authorization_callback.handle": slatesMessageAuthAuthorizationCallbackHandleRequest,
+  "slates/auth.admin_authorization_url.get": slatesMessageAuthAdminAuthorizationUrlGetRequest,
+  "slates/auth.admin_callback.handle": slatesMessageAuthAdminCallbackHandleRequest,
   "slates/auth.token_refresh.handle": slatesMessageAuthTokenRefreshHandleRequest,
   "slates/auth.profile.get": slatesMessageAuthProfileGetRequest,
   "slates/auth.output.get": slatesMessageAuthOutputGetRequest
@@ -560,69 +640,69 @@ var slatesAuthNotificationsByMethod = {
 };
 
 // src/messages/config.ts
-import z11 from "zod";
-var slatesMessageSetConfigNotification = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  method: z11.literal("slates/config.set"),
-  params: z11.object({
-    config: z11.record(z11.string(), z11.any())
+import z12 from "zod";
+var slatesMessageSetConfigNotification = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  method: z12.literal("slates/config.set"),
+  params: z12.object({
+    config: z12.record(z12.string(), z12.any())
   })
 });
-var slatesMessageConfigSchemaGetRequest = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  method: z11.literal("slates/config.schema.get"),
-  id: z11.string(),
-  params: z11.object({})
+var slatesMessageConfigSchemaGetRequest = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  method: z12.literal("slates/config.schema.get"),
+  id: z12.string(),
+  params: z12.object({})
 });
-var slatesMessageConfigSchemaGetResponse = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  id: z11.string(),
-  result: z11.object({
-    schema: z11.record(z11.string(), z11.any()),
-    docs: z11.array(
-      z11.object({
-        type: z11.literal("docs.config.general").optional(),
-        name: z11.string(),
-        url: z11.string()
+var slatesMessageConfigSchemaGetResponse = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  id: z12.string(),
+  result: z12.object({
+    schema: z12.record(z12.string(), z12.any()),
+    docs: z12.array(
+      z12.object({
+        type: z12.literal("docs.config.general").optional(),
+        name: z12.string(),
+        url: z12.string()
       })
     )
   })
 });
-var slatesMessageConfigChangedRequest = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  method: z11.literal("slates/config.changed"),
-  id: z11.string(),
-  params: z11.object({
-    previousConfig: z11.record(z11.string(), z11.any()).nullable(),
-    newConfig: z11.record(z11.string(), z11.any())
+var slatesMessageConfigChangedRequest = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  method: z12.literal("slates/config.changed"),
+  id: z12.string(),
+  params: z12.object({
+    previousConfig: z12.record(z12.string(), z12.any()).nullable(),
+    newConfig: z12.record(z12.string(), z12.any())
   })
 });
-var slatesMessageConfigChangedResponse = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  id: z11.string(),
+var slatesMessageConfigChangedResponse = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  id: z12.string(),
   result: withRequestTraces({
-    success: z11.boolean(),
-    config: z11.record(z11.string(), z11.any()).optional(),
-    errors: z11.array(
-      z11.object({
-        code: z11.string(),
-        message: z11.string(),
-        path: z11.array(z11.string()).optional()
+    success: z12.boolean(),
+    config: z12.record(z12.string(), z12.any()).optional(),
+    errors: z12.array(
+      z12.object({
+        code: z12.string(),
+        message: z12.string(),
+        path: z12.array(z12.string()).optional()
       })
     ).optional()
   })
 });
-var slatesMessageConfigDefaultGetRequest = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  method: z11.literal("slates/config.get_default"),
-  id: z11.string(),
-  params: z11.object({})
+var slatesMessageConfigDefaultGetRequest = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  method: z12.literal("slates/config.get_default"),
+  id: z12.string(),
+  params: z12.object({})
 });
-var slatesMessageConfigDefaultGetResponse = z11.object({
-  jsonrpc: z11.literal("2.0"),
-  id: z11.string(),
+var slatesMessageConfigDefaultGetResponse = z12.object({
+  jsonrpc: z12.literal("2.0"),
+  id: z12.string(),
   result: withRequestTraces({
-    config: z11.record(z11.string(), z11.any()).nullable()
+    config: z12.record(z12.string(), z12.any()).nullable()
   })
 });
 var slatesConfigResponsesByMethod = {
@@ -640,32 +720,32 @@ var slatesConfigNotificationsByMethod = {
 };
 
 // src/messages/controlFlow.ts
-import z12 from "zod";
+import z13 from "zod";
 
 // src/version.ts
 var SLATES_PROTOCOL_VERSION = "slates@2026-01-01";
 
 // src/messages/controlFlow.ts
-var slatesMessageHelloNotification = z12.object({
-  jsonrpc: z12.literal("2.0"),
-  method: z12.literal("slates/hello"),
-  params: z12.object({
-    protocol: z12.literal(SLATES_PROTOCOL_VERSION)
+var slatesMessageHelloNotification = z13.object({
+  jsonrpc: z13.literal("2.0"),
+  method: z13.literal("slates/hello"),
+  params: z13.object({
+    protocol: z13.literal(SLATES_PROTOCOL_VERSION)
   })
 });
-var slatesMessageSetParticipantsNotification = z12.object({
-  jsonrpc: z12.literal("2.0"),
-  method: z12.literal("slates/participant.set"),
-  params: z12.object({
-    participants: z12.array(slatesParticipant)
+var slatesMessageSetParticipantsNotification = z13.object({
+  jsonrpc: z13.literal("2.0"),
+  method: z13.literal("slates/participant.set"),
+  params: z13.object({
+    participants: z13.array(slatesParticipant)
   })
 });
-var slatesMessageSessionStartNotification = z12.object({
-  jsonrpc: z12.literal("2.0"),
-  method: z12.literal("slates/session.start"),
-  params: z12.object({
-    sessionId: z12.string(),
-    state: z12.record(z12.string(), z12.any())
+var slatesMessageSessionStartNotification = z13.object({
+  jsonrpc: z13.literal("2.0"),
+  method: z13.literal("slates/session.start"),
+  params: z13.object({
+    sessionId: z13.string(),
+    state: z13.record(z13.string(), z13.any())
   })
 });
 var slatesControlFlowNotificationsByMethod = {
@@ -675,53 +755,53 @@ var slatesControlFlowNotificationsByMethod = {
 };
 
 // src/messages/hub.ts
-import z13 from "zod";
-var slatesMessageHubCapabilitiesSetNotification = z13.object({
-  jsonrpc: z13.literal("2.0"),
-  method: z13.literal("slates/hub.capabilities.set"),
-  params: z13.object({
-    capabilities: z13.object({
-      attachments: z13.object({
-        directUpload: z13.object({
-          enabled: z13.boolean(),
-          maxAttachmentSizeBytes: z13.number().optional()
+import z14 from "zod";
+var slatesMessageHubCapabilitiesSetNotification = z14.object({
+  jsonrpc: z14.literal("2.0"),
+  method: z14.literal("slates/hub.capabilities.set"),
+  params: z14.object({
+    capabilities: z14.object({
+      attachments: z14.object({
+        directUpload: z14.object({
+          enabled: z14.boolean(),
+          maxAttachmentSizeBytes: z14.number().optional()
         })
       }).optional(),
-      adapters: z13.boolean().optional(),
-      triggers: z13.boolean().optional()
+      adapters: z14.boolean().optional(),
+      triggers: z14.boolean().optional()
     })
   })
 });
-var slatesMessageHubLiveInvocationSetNotification = z13.object({
-  jsonrpc: z13.literal("2.0"),
-  method: z13.literal("slates/hub.live_invocation.set"),
-  params: z13.object({
-    token: z13.string(),
-    baseUrl: z13.string()
+var slatesMessageHubLiveInvocationSetNotification = z14.object({
+  jsonrpc: z14.literal("2.0"),
+  method: z14.literal("slates/hub.live_invocation.set"),
+  params: z14.object({
+    token: z14.string(),
+    baseUrl: z14.string()
   })
 });
 var slatesHubNotificationsByMethod = {
   "slates/hub.capabilities.set": slatesMessageHubCapabilitiesSetNotification,
   "slates/hub.live_invocation.set": slatesMessageHubLiveInvocationSetNotification
 };
-var slatesMessageProviderCapabilitiesGetRequest = z13.object({
-  jsonrpc: z13.literal("2.0"),
-  method: z13.literal("slates/provider.capabilities.get"),
-  id: z13.string(),
-  params: z13.object({})
+var slatesMessageProviderCapabilitiesGetRequest = z14.object({
+  jsonrpc: z14.literal("2.0"),
+  method: z14.literal("slates/provider.capabilities.get"),
+  id: z14.string(),
+  params: z14.object({})
 });
-var slatesMessageProviderCapabilitiesGetResponse = z13.object({
-  jsonrpc: z13.literal("2.0"),
-  id: z13.string(),
-  result: z13.object({
-    capabilities: z13.object({
-      hub: z13.object({
-        capabilitiesNotification: z13.boolean().optional(),
-        liveInvocation: z13.boolean().optional()
+var slatesMessageProviderCapabilitiesGetResponse = z14.object({
+  jsonrpc: z14.literal("2.0"),
+  id: z14.string(),
+  result: z14.object({
+    capabilities: z14.object({
+      hub: z14.object({
+        capabilitiesNotification: z14.boolean().optional(),
+        liveInvocation: z14.boolean().optional()
       }).optional(),
-      provider: z13.object({
-        triggerGroups: z13.boolean().optional(),
-        toolCategories: z13.boolean().optional()
+      provider: z14.object({
+        triggerGroups: z14.boolean().optional(),
+        toolCategories: z14.boolean().optional()
       }).optional()
     })
   })
@@ -734,29 +814,29 @@ var slatesHubResponsesByMethod = {
 };
 
 // src/messages/identify.ts
-import z14 from "zod";
-var slatesMessageProviderIdentifyRequest = z14.object({
-  jsonrpc: z14.literal("2.0"),
-  method: z14.literal("slates/provider.identify"),
-  id: z14.string(),
-  params: z14.object({})
+import z15 from "zod";
+var slatesMessageProviderIdentifyRequest = z15.object({
+  jsonrpc: z15.literal("2.0"),
+  method: z15.literal("slates/provider.identify"),
+  id: z15.string(),
+  params: z15.object({})
 });
-var slatesMessageProviderIdentifyResponse = z14.object({
-  jsonrpc: z14.literal("2.0"),
-  id: z14.string(),
-  result: z14.object({
-    protocol: z14.literal(SLATES_PROTOCOL_VERSION),
-    provider: z14.object({
-      type: z14.literal("provider"),
-      id: z14.string(),
-      name: z14.string(),
-      description: z14.string().optional(),
-      metadata: z14.record(z14.string(), z14.any()).optional()
+var slatesMessageProviderIdentifyResponse = z15.object({
+  jsonrpc: z15.literal("2.0"),
+  id: z15.string(),
+  result: z15.object({
+    protocol: z15.literal(SLATES_PROTOCOL_VERSION),
+    provider: z15.object({
+      type: z15.literal("provider"),
+      id: z15.string(),
+      name: z15.string(),
+      description: z15.string().optional(),
+      metadata: z15.record(z15.string(), z15.any()).optional()
     }),
-    docs: z14.array(
-      z14.object({
-        name: z14.string(),
-        url: z14.string()
+    docs: z15.array(
+      z15.object({
+        name: z15.string(),
+        url: z15.string()
       })
     )
   })
@@ -769,81 +849,81 @@ var slatesIdentifyRequestsByMethod = {
 };
 
 // src/messages/legacyTrigger.ts
-import z15 from "zod";
-var slatesMessageActionTriggerEventsPollRequest = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  method: z15.literal("slates/action.trigger.poll_events"),
-  id: z15.string(),
-  params: z15.object({
-    actionId: z15.string(),
-    state: z15.any().nullable()
+import z16 from "zod";
+var slatesMessageActionTriggerEventsPollRequest = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  method: z16.literal("slates/action.trigger.poll_events"),
+  id: z16.string(),
+  params: z16.object({
+    actionId: z16.string(),
+    state: z16.any().nullable()
   })
 });
-var slatesMessageActionTriggerEventsPollResponse = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  id: z15.string(),
+var slatesMessageActionTriggerEventsPollResponse = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  id: z16.string(),
   result: withRequestTraces({
-    inputs: z15.array(z15.record(z15.string(), z15.any())),
-    updatedState: z15.any().nullable().optional()
+    inputs: z16.array(z16.record(z16.string(), z16.any())),
+    updatedState: z16.any().nullable().optional()
   })
 });
-var slatesMessageActionTriggerWebhookHandleRequest = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  method: z15.literal("slates/action.trigger.webhook_handle"),
-  id: z15.string(),
-  params: z15.object({
-    actionId: z15.string(),
-    url: z15.string(),
-    method: z15.string(),
-    headers: z15.record(z15.string(), z15.string()),
-    body: z15.object({
-      encoding: z15.literal("base64"),
-      content: z15.string()
+var slatesMessageActionTriggerWebhookHandleRequest = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  method: z16.literal("slates/action.trigger.webhook_handle"),
+  id: z16.string(),
+  params: z16.object({
+    actionId: z16.string(),
+    url: z16.string(),
+    method: z16.string(),
+    headers: z16.record(z16.string(), z16.string()),
+    body: z16.object({
+      encoding: z16.literal("base64"),
+      content: z16.string()
     }).nullable(),
-    state: z15.any().nullable(),
-    registrationDetails: z15.any().nullable().optional()
+    state: z16.any().nullable(),
+    registrationDetails: z16.any().nullable().optional()
   })
 });
-var slatesMessageActionTriggerWebhookHandleResponse = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  id: z15.string(),
+var slatesMessageActionTriggerWebhookHandleResponse = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  id: z16.string(),
   result: withRequestTraces({
-    inputs: z15.array(z15.record(z15.string(), z15.any())),
-    updatedState: z15.any().nullable().optional(),
+    inputs: z16.array(z16.record(z16.string(), z16.any())),
+    updatedState: z16.any().nullable().optional(),
     response: slatesWebhookHttpResponse.nullable().optional()
   })
 });
-var slatesMessageActionTriggerWebhookRegisterRequest = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  method: z15.literal("slates/action.trigger.webhook_register"),
-  id: z15.string(),
-  params: z15.object({
-    actionId: z15.string(),
-    webhookBaseUrl: z15.string()
+var slatesMessageActionTriggerWebhookRegisterRequest = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  method: z16.literal("slates/action.trigger.webhook_register"),
+  id: z16.string(),
+  params: z16.object({
+    actionId: z16.string(),
+    webhookBaseUrl: z16.string()
   })
 });
-var slatesMessageActionTriggerWebhookRegisterResponse = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  id: z15.string(),
+var slatesMessageActionTriggerWebhookRegisterResponse = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  id: z16.string(),
   result: withRequestTraces({
-    registrationDetails: z15.any(),
-    state: z15.any().optional()
+    registrationDetails: z16.any(),
+    state: z16.any().optional()
   })
 });
-var slatesMessageActionTriggerWebhookUnregisterRequest = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  method: z15.literal("slates/action.trigger.webhook_unregister"),
-  id: z15.string(),
-  params: z15.object({
-    actionId: z15.string(),
-    webhookBaseUrl: z15.string(),
-    registrationDetails: z15.any(),
-    state: z15.any().optional()
+var slatesMessageActionTriggerWebhookUnregisterRequest = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  method: z16.literal("slates/action.trigger.webhook_unregister"),
+  id: z16.string(),
+  params: z16.object({
+    actionId: z16.string(),
+    webhookBaseUrl: z16.string(),
+    registrationDetails: z16.any(),
+    state: z16.any().optional()
   })
 });
-var slatesMessageActionTriggerWebhookUnregisterResponse = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  id: z15.string(),
+var slatesMessageActionTriggerWebhookUnregisterResponse = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  id: z16.string(),
   result: withRequestTraces({})
 });
 var slatesLegacyTriggerResponsesByMethod = {
@@ -860,18 +940,18 @@ var slatesLegacyTriggerRequestsByMethod = {
 };
 
 // src/messages/toolCategory.ts
-import z16 from "zod";
-var slatesMessageToolCategoriesListRequest = z16.object({
-  jsonrpc: z16.literal("2.0"),
-  method: z16.literal("slates/tool_categories.list"),
-  id: z16.string(),
-  params: z16.object({})
+import z17 from "zod";
+var slatesMessageToolCategoriesListRequest = z17.object({
+  jsonrpc: z17.literal("2.0"),
+  method: z17.literal("slates/tool_categories.list"),
+  id: z17.string(),
+  params: z17.object({})
 });
-var slatesMessageToolCategoriesListResponse = z16.object({
-  jsonrpc: z16.literal("2.0"),
-  id: z16.string(),
-  result: z16.object({
-    toolCategories: z16.array(slatesToolCategory)
+var slatesMessageToolCategoriesListResponse = z17.object({
+  jsonrpc: z17.literal("2.0"),
+  id: z17.string(),
+  result: z17.object({
+    toolCategories: z17.array(slatesToolCategory)
   })
 });
 var slatesToolCategoryResponsesByMethod = {
@@ -882,237 +962,237 @@ var slatesToolCategoryRequestsByMethod = {
 };
 
 // src/messages/triggerGroup.ts
-import z17 from "zod";
-var slatesTriggerGroupWebhookEvent = z17.object({
-  matchers: z17.array(slatesTriggerRoutingMatcher),
-  payload: z17.record(z17.string(), z17.any()),
-  idempotencyKey: z17.string().optional(),
-  triggerIds: z17.array(z17.string())
-});
-var slatesTriggerGroupWebhookSkipped = z17.object({
-  reason: z17.string()
-});
-var slatesTriggerGroupPollEvent = z17.object({
-  payload: z17.record(z17.string(), z17.any()),
-  idempotencyKey: z17.string().optional(),
-  triggerIds: z17.array(z17.string())
-});
-var slatesMessageTriggerGroupsListRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_groups.list"),
-  id: z17.string(),
-  params: z17.object({})
-});
-var slatesMessageTriggerGroupsListResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
-  result: z17.object({
-    triggerGroups: z17.array(slatesTriggerGroup)
-  })
-});
-var slatesMessageTriggerGroupGetRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.get"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string()
-  })
-});
-var slatesMessageTriggerGroupGetResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
-  result: z17.object({
+import z18 from "zod";
+var slatesTriggerGroupWebhookEvent = z18.object({
+  matchers: z18.array(slatesTriggerRoutingMatcher),
+  payload: z18.record(z18.string(), z18.any()),
+  idempotencyKey: z18.string().optional(),
+  triggerIds: z18.array(z18.string())
+});
+var slatesTriggerGroupWebhookSkipped = z18.object({
+  reason: z18.string()
+});
+var slatesTriggerGroupPollEvent = z18.object({
+  payload: z18.record(z18.string(), z18.any()),
+  idempotencyKey: z18.string().optional(),
+  triggerIds: z18.array(z18.string())
+});
+var slatesMessageTriggerGroupsListRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_groups.list"),
+  id: z18.string(),
+  params: z18.object({})
+});
+var slatesMessageTriggerGroupsListResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
+  result: z18.object({
+    triggerGroups: z18.array(slatesTriggerGroup)
+  })
+});
+var slatesMessageTriggerGroupGetRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.get"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string()
+  })
+});
+var slatesMessageTriggerGroupGetResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
+  result: z18.object({
     triggerGroup: slatesTriggerGroup
   })
 });
-var slatesMessageTriggerGroupWebhookTargetsListRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.targets_list"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    pageToken: z17.any().nullable().optional()
+var slatesMessageTriggerGroupWebhookTargetsListRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.targets_list"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    pageToken: z18.any().nullable().optional()
   })
 });
-var slatesMessageTriggerGroupWebhookTargetsListResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupWebhookTargetsListResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    targets: z17.array(slatesWebhookTarget),
-    nextPageToken: z17.any().nullable(),
-    isPartial: z17.boolean().optional()
+    targets: z18.array(slatesWebhookTarget),
+    nextPageToken: z18.any().nullable(),
+    isPartial: z18.boolean().optional()
   })
 });
-var slatesMessageTriggerGroupWebhookRegisterRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.register"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    webhookTargetIdentifier: z17.string(),
-    webhookTargetPayload: z17.any(),
-    webhookUrl: z17.string()
+var slatesMessageTriggerGroupWebhookRegisterRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.register"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    webhookTargetIdentifier: z18.string(),
+    webhookTargetPayload: z18.any(),
+    webhookUrl: z18.string()
   })
 });
-var slatesMessageTriggerGroupWebhookRegisterResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupWebhookRegisterResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    webhookRegistrationIdentifier: z17.string(),
-    webhookRegistrationPayload: z17.any()
+    webhookRegistrationIdentifier: z18.string(),
+    webhookRegistrationPayload: z18.any()
   })
 });
-var slatesMessageTriggerGroupWebhookUnregisterRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.unregister"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    webhookRegistrationIdentifier: z17.string(),
-    webhookRegistrationPayload: z17.any()
+var slatesMessageTriggerGroupWebhookUnregisterRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.unregister"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    webhookRegistrationIdentifier: z18.string(),
+    webhookRegistrationPayload: z18.any()
   })
 });
-var slatesMessageTriggerGroupWebhookUnregisterResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupWebhookUnregisterResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({})
 });
-var slatesMessageTriggerGroupWebhookManualSetupRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.manual_setup"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    webhookUrl: z17.string()
-  })
-});
-var slatesMessageTriggerGroupWebhookManualSetupResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
-  result: z17.object({
-    webhookSetupDocument: z17.string(),
-    partialWebhookRegistrationPayload: z17.any()
-  })
-});
-var slatesMessageTriggerGroupWebhookManualFinishRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.manual_finish"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    webhookUrl: z17.string(),
-    partialWebhookRegistrationPayload: z17.any(),
-    userWebhookRegistrationPayload: z17.any()
-  })
-});
-var slatesMessageTriggerGroupWebhookManualFinishResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupWebhookManualSetupRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.manual_setup"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    webhookUrl: z18.string()
+  })
+});
+var slatesMessageTriggerGroupWebhookManualSetupResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
+  result: z18.object({
+    webhookSetupDocument: z18.string(),
+    partialWebhookRegistrationPayload: z18.any()
+  })
+});
+var slatesMessageTriggerGroupWebhookManualFinishRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.manual_finish"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    webhookUrl: z18.string(),
+    partialWebhookRegistrationPayload: z18.any(),
+    userWebhookRegistrationPayload: z18.any()
+  })
+});
+var slatesMessageTriggerGroupWebhookManualFinishResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    webhookRegistrationPayload: z17.any()
-  })
-});
-var slatesMessageTriggerGroupWebhookProcessRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.webhook.process"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    url: z17.string(),
-    method: z17.string(),
-    headers: z17.record(z17.string(), z17.string()),
-    body: z17.object({
-      encoding: z17.literal("base64"),
-      content: z17.string()
+    webhookRegistrationPayload: z18.any()
+  })
+});
+var slatesMessageTriggerGroupWebhookProcessRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.webhook.process"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    url: z18.string(),
+    method: z18.string(),
+    headers: z18.record(z18.string(), z18.string()),
+    body: z18.object({
+      encoding: z18.literal("base64"),
+      content: z18.string()
     }).nullable(),
-    webhookRegistrationPayload: z17.any()
+    webhookRegistrationPayload: z18.any()
   })
 });
-var slatesMessageTriggerGroupWebhookProcessResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupWebhookProcessResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    events: z17.array(slatesTriggerGroupWebhookEvent),
+    events: z18.array(slatesTriggerGroupWebhookEvent),
     response: slatesWebhookHttpResponse.nullable().optional(),
     skipped: slatesTriggerGroupWebhookSkipped.nullable().optional()
   })
 });
-var slatesMessageTriggerGroupRoutingMatchersGetRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.routing_matchers.get"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string()
+var slatesMessageTriggerGroupRoutingMatchersGetRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.routing_matchers.get"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string()
   })
 });
-var slatesMessageTriggerGroupRoutingMatchersGetResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupRoutingMatchersGetResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    matchers: z17.array(slatesTriggerRoutingMatcher)
+    matchers: z18.array(slatesTriggerRoutingMatcher)
   })
 });
-var slatesMessageTriggerGroupPollingPollRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.polling.poll"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    state: z17.any().nullable()
+var slatesMessageTriggerGroupPollingPollRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.polling.poll"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    state: z18.any().nullable()
   })
 });
-var slatesMessageTriggerGroupPollingPollResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupPollingPollResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    updatedState: z17.any().nullable().optional(),
-    events: z17.array(slatesTriggerGroupPollEvent)
+    updatedState: z18.any().nullable().optional(),
+    events: z18.array(slatesTriggerGroupPollEvent)
   })
 });
-var slatesMessageTriggerGroupGatewayConnectRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.gateway.connect"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    state: z17.any().nullable()
+var slatesMessageTriggerGroupGatewayConnectRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.gateway.connect"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    state: z18.any().nullable()
   })
 });
-var slatesMessageTriggerGroupGatewayConnectResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupGatewayConnectResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    url: z17.string(),
-    state: z17.any().nullable().optional()
+    url: z18.string(),
+    state: z18.any().nullable().optional()
   })
 });
-var slatesMessageTriggerGroupGatewayReceiveRequest = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  method: z17.literal("slates/trigger_group.gateway.receive"),
-  id: z17.string(),
-  params: z17.object({
-    triggerGroupId: z17.string(),
-    state: z17.any().nullable(),
-    frames: z17.array(z17.string()),
-    closed: z17.object({ code: z17.number(), reason: z17.string() }).nullable().optional()
+var slatesMessageTriggerGroupGatewayReceiveRequest = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  method: z18.literal("slates/trigger_group.gateway.receive"),
+  id: z18.string(),
+  params: z18.object({
+    triggerGroupId: z18.string(),
+    state: z18.any().nullable(),
+    frames: z18.array(z18.string()),
+    closed: z18.object({ code: z18.number(), reason: z18.string() }).nullable().optional()
   })
 });
-var slatesMessageTriggerGroupGatewayReceiveResponse = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.string(),
+var slatesMessageTriggerGroupGatewayReceiveResponse = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.string(),
   result: withRequestTraces({
-    state: z17.any().nullable().optional(),
-    send: z17.array(z17.string()),
-    events: z17.array(slatesTriggerGroupPollEvent),
-    heartbeat: z17.object({
-      intervalMs: z17.number().int().positive(),
-      frame: z17.string(),
+    state: z18.any().nullable().optional(),
+    send: z18.array(z18.string()),
+    events: z18.array(slatesTriggerGroupPollEvent),
+    heartbeat: z18.object({
+      intervalMs: z18.number().int().positive(),
+      frame: z18.string(),
       // The hub requires `heartbeatAcked` between beats and reconnects otherwise.
-      expectsAck: z17.boolean().optional()
+      expectsAck: z18.boolean().optional()
     }).nullable().optional(),
     // Set when these frames included the provider's acknowledgement of a heartbeat.
-    heartbeatAcked: z17.boolean().optional(),
-    close: z17.object({ reconnect: z17.boolean(), reason: z17.string().optional() }).nullable().optional()
+    heartbeatAcked: z18.boolean().optional(),
+    close: z18.object({ reconnect: z18.boolean(), reason: z18.string().optional() }).nullable().optional()
   })
 });
 var slatesTriggerGroupResponsesByMethod = {
@@ -1304,7 +1384,7 @@ var createSlatesProviderProtoHandler = (cb) => ({
 });
 var toSlateErrorResponse = (error, defaults = {}) => {
   let slateError = getSlateErrorResponse(error);
-  if (slateError) return slateError;
+  if (slateError) return withUpstreamCode(slateError);
   let serviceError = getServiceErrorData(error);
   if (serviceError) {
     return mapServiceErrorToSlateErrorResponse(serviceError, defaults);
@@ -1357,6 +1437,13 @@ var getServiceErrorData = (error) => {
   }
   return null;
 };
+var UPSTREAM_CODE_PATTERN = /^[\w.:-]{1,128}$/;
+var normalizeUpstreamCode = (value) => typeof value === "string" && UPSTREAM_CODE_PATTERN.test(value) ? value : void 0;
+var withUpstreamCode = (response) => {
+  let { upstreamCode: rawUpstreamCode, ...rest } = response;
+  let upstreamCode = normalizeUpstreamCode(rawUpstreamCode) ?? normalizeUpstreamCode(response.upstream?.code);
+  return upstreamCode ? { ...rest, upstreamCode } : rest;
+};
 var mapKind = (code) => {
   if (code.startsWith("declaration.")) return "declaration";
   if (code.startsWith("input.")) return "validation";
@@ -1404,6 +1491,7 @@ var mapIssues = (errors) => {
 };
 var mapServiceErrorToSlateErrorResponse = (error, defaults = {}) => {
   let code = defaults.code ?? mapServiceErrorCode(error.code, error.status);
+  let upstreamCode = normalizeUpstreamCode(error.upstreamCode);
   let extraEntries = Object.entries(error).filter(
     ([key]) => ![
       "status",
@@ -1424,6 +1512,7 @@ var mapServiceErrorToSlateErrorResponse = (error, defaults = {}) => {
     retryable: mapRetryable(code),
     status: error.status,
     ...mapIssues(error.errors) ? { issues: mapIssues(error.errors) } : {},
+    ...upstreamCode ? { upstreamCode } : {},
     baggage: {
       serviceError: {
         code: error.code,
@@ -1473,6 +1562,7 @@ export {
   slatesConfigRequestsByMethod,
   slatesConfigResponsesByMethod,
   slatesControlFlowNotificationsByMethod,
+  slatesErrorResponse,
   slatesHubNotificationsByMethod,
   slatesHubRequestsByMethod,
   slatesHubResponsesByMethod,
@@ -1500,6 +1590,10 @@ export {
   slatesMessageAdapterGetResponse,
   slatesMessageAdaptersListRequest,
   slatesMessageAdaptersListResponse,
+  slatesMessageAuthAdminAuthorizationUrlGetRequest,
+  slatesMessageAuthAdminAuthorizationUrlGetResponse,
+  slatesMessageAuthAdminCallbackHandleRequest,
+  slatesMessageAuthAdminCallbackHandleResponse,
   slatesMessageAuthAuthorizationCallbackHandleRequest,
   slatesMessageAuthAuthorizationCallbackHandleResponse,
   slatesMessageAuthAuthorizationUrlGetRequest,