@vm0/cli 9.278.0 → 9.278.1

package/chunk-HZYOJTEE.js

@@ -0,0 +1,1275 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  connectorExternalCodeSessionCompleteRequestSchema,
+  connectorExternalCodeSessionCompleteResponseSchema,
+  connectorExternalCodeSessionStartResponseSchema,
+  connectorListResponseSchema,
+  connectorOauthDeviceAuthSessionPollRequestSchema,
+  connectorOauthDeviceAuthSessionPollResponseSchema,
+  connectorOauthDeviceAuthSessionStartResponseSchema,
+  connectorOauthStartResponseSchema,
+  connectorResponseSchema,
+  scopeDiffResponseSchema
+} from "./chunk-HHHHZMTA.js";
+import {
+  persistedAttachmentSchema,
+  requireUserMessageForDraftAttachments,
+  userMessageDocumentSchema
+} from "./chunk-DUA6CF7E.js";
+import {
+  connectorAuthMethodIdSchema,
+  connectorSlugSchema
+} from "./chunk-SMPSKBAP.js";
+import {
+  authHeadersSchema
+} from "./chunk-JV6LM2YC.js";
+import {
+  apiErrorSchema,
+  external_exports,
+  initContract
+} from "./chunk-GHKWW4NC.js";
+import {
+  init_esm_shims
+} from "./chunk-AUWSMG4F.js";
+
+// ../../packages/api-contracts/src/contracts/zero-agents.ts
+init_esm_shims();
+var c = initContract();
+var zeroAgentVisibilitySchema = external_exports.enum(["public", "private"]);
+var zeroAgentResponseSchema = external_exports.object({
+  agentId: external_exports.string(),
+  ownerId: external_exports.string(),
+  description: external_exports.string().nullable(),
+  displayName: external_exports.string().nullable(),
+  sound: external_exports.string().nullable(),
+  avatarUrl: external_exports.string().nullable(),
+  modelProviderId: external_exports.string().uuid().nullable().default(null),
+  selectedModel: external_exports.string().nullable().default(null),
+  preferPersonalProvider: external_exports.boolean().default(false),
+  visibility: zeroAgentVisibilitySchema.optional()
+});
+var zeroAgentRequestSchema = external_exports.object({
+  description: external_exports.string().optional(),
+  displayName: external_exports.string().optional(),
+  sound: external_exports.string().optional(),
+  avatarUrl: external_exports.string().optional(),
+  visibility: zeroAgentVisibilitySchema.optional()
+});
+var zeroAgentMetadataRequestSchema = external_exports.object({
+  displayName: external_exports.string().optional(),
+  description: external_exports.string().optional(),
+  sound: external_exports.string().optional(),
+  avatarUrl: external_exports.string().nullable().optional(),
+  visibility: zeroAgentVisibilitySchema.optional()
+});
+var zeroAgentInstructionsResponseSchema = external_exports.object({
+  content: external_exports.string().nullable(),
+  filename: external_exports.string().nullable()
+});
+var zeroAgentInstructionsRequestSchema = external_exports.object({
+  content: external_exports.string()
+});
+var zeroAgentDraftResponseSchema = external_exports.object({
+  draftUserMessage: userMessageDocumentSchema.nullable(),
+  draftAttachments: external_exports.array(persistedAttachmentSchema).nullable()
+}).superRefine(requireUserMessageForDraftAttachments);
+var zeroAgentDraftRequestSchema = external_exports.object({
+  draftUserMessage: userMessageDocumentSchema.nullable(),
+  draftAttachments: external_exports.array(persistedAttachmentSchema).nullable().optional()
+}).superRefine(requireUserMessageForDraftAttachments);
+var zeroAgentsMainContract = c.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/agents",
+    headers: authHeadersSchema,
+    body: zeroAgentRequestSchema,
+    responses: {
+      201: zeroAgentResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      409: apiErrorSchema,
+      422: apiErrorSchema
+    },
+    summary: "Create zero agent"
+  },
+  list: {
+    method: "GET",
+    path: "/api/zero/agents",
+    headers: authHeadersSchema,
+    responses: {
+      200: external_exports.array(zeroAgentResponseSchema),
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "List zero agents"
+  }
+});
+var zeroAgentsByIdContract = c.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: zeroAgentResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get zero agent by id"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: zeroAgentRequestSchema,
+    responses: {
+      200: zeroAgentResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema,
+      422: apiErrorSchema
+    },
+    summary: "Update zero agent"
+  },
+  updateMetadata: {
+    method: "PATCH",
+    path: "/api/zero/agents/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: zeroAgentMetadataRequestSchema,
+    responses: {
+      200: zeroAgentResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Update zero agent metadata"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/agents/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: c.noBody(),
+    responses: {
+      204: c.noBody(),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Delete zero agent by id"
+  }
+});
+var zeroAgentInstructionsContract = c.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/instructions",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: zeroAgentInstructionsResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get zero agent instructions"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id/instructions",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: zeroAgentInstructionsRequestSchema,
+    responses: {
+      200: zeroAgentResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      422: apiErrorSchema
+    },
+    summary: "Update zero agent instructions"
+  }
+});
+var zeroAgentDraftContract = c.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/draft",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: zeroAgentDraftResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get zero agent draft"
+  },
+  patch: {
+    method: "PATCH",
+    path: "/api/zero/agents/:id/draft",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: zeroAgentDraftRequestSchema,
+    responses: {
+      204: c.noBody(),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Update zero agent draft"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-user-permission-grants.ts
+init_esm_shims();
+var c2 = initContract();
+var agentIdSchema = external_exports.string().uuid();
+var permissionSchema = external_exports.string().min(1).max(128);
+var userPermissionGrantActionSchema = external_exports.enum(["allow", "deny"]);
+var userPermissionGrantApplyModeSchema = external_exports.enum(["patch", "replace"]);
+var userPermissionGrantExpiresInSchema = external_exports.enum([
+  "1h",
+  "24h",
+  "7d",
+  "always"
+]);
+var agentPermissionGrantScopeSchema = external_exports.object({
+  agentId: agentIdSchema
+});
+var userPermissionGrantScopeSchema = agentPermissionGrantScopeSchema;
+var userPermissionGrantResponseBaseSchema = external_exports.object({
+  connectorSlug: connectorSlugSchema,
+  permission: permissionSchema,
+  action: userPermissionGrantActionSchema,
+  expiresAt: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var userPermissionGrantResponseSchema = userPermissionGrantResponseBaseSchema.extend({
+  agentId: agentIdSchema
+});
+var listUserPermissionGrantsQuerySchema = userPermissionGrantScopeSchema;
+var applyUserPermissionGrantBaseSchema = external_exports.object({
+  permission: permissionSchema
+});
+var applyUserPermissionGrantSchema = external_exports.discriminatedUnion("action", [
+  applyUserPermissionGrantBaseSchema.extend({
+    action: external_exports.literal("allow"),
+    expiresIn: userPermissionGrantExpiresInSchema.optional()
+  }),
+  applyUserPermissionGrantBaseSchema.extend({
+    action: external_exports.literal("deny"),
+    expiresIn: external_exports.never().optional()
+  })
+]);
+var applyUserPermissionGrantsRequestSchema = external_exports.object({
+  agentId: agentIdSchema,
+  connectorSlug: connectorSlugSchema,
+  mode: userPermissionGrantApplyModeSchema,
+  grants: external_exports.array(applyUserPermissionGrantSchema)
+}).strict();
+var zeroUserPermissionGrantsContract = c2.router({
+  list: {
+    method: "GET",
+    path: "/api/zero/user-permission-grants",
+    headers: authHeadersSchema,
+    query: listUserPermissionGrantsQuerySchema,
+    responses: {
+      200: external_exports.array(userPermissionGrantResponseSchema),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "List current user's active permission grants for an agent"
+  },
+  apply: {
+    method: "PUT",
+    path: "/api/zero/user-permission-grants/apply",
+    headers: authHeadersSchema,
+    body: applyUserPermissionGrantsRequestSchema,
+    responses: {
+      200: external_exports.array(userPermissionGrantResponseSchema),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Apply current user's explicit permission grant changes for one connector"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/user-connectors.ts
+init_esm_shims();
+var c3 = initContract();
+var userConnectorEnabledSlugsSchema = external_exports.object({
+  enabledConnectorSlugs: external_exports.array(connectorSlugSchema)
+});
+var userConnectorUpdateSchema = external_exports.object({
+  enabledConnectorSlugs: external_exports.array(connectorSlugSchema),
+  operation: external_exports.enum(["replace", "add", "remove"]).optional()
+}).strict();
+var zeroUserConnectorsContract = c3.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/user-connectors",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: userConnectorEnabledSlugsSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get enabled connector slugs for user on agent"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id/user-connectors",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: userConnectorUpdateSchema,
+    responses: {
+      200: userConnectorEnabledSlugsSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Update enabled connector slugs for user on agent"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-agent-custom-connectors.ts
+init_esm_shims();
+var c4 = initContract();
+var agentCustomConnectorEnabledIdsSchema = external_exports.object({
+  enabledIds: external_exports.array(external_exports.string().uuid())
+});
+var agentCustomConnectorGrantSchema = external_exports.object({
+  customConnectorId: external_exports.string().uuid(),
+  permissionNames: external_exports.array(external_exports.string().min(1).max(128)).max(500)
+});
+var agentCustomConnectorGrantsSchema = external_exports.object({
+  grants: external_exports.array(agentCustomConnectorGrantSchema)
+});
+var agentCustomConnectorResponseSchema = agentCustomConnectorEnabledIdsSchema.extend({
+  grants: external_exports.array(agentCustomConnectorGrantSchema).optional()
+});
+var legacyAgentCustomConnectorUpdateSchema = agentCustomConnectorEnabledIdsSchema.extend({
+  operation: external_exports.enum(["replace", "add", "remove"]).optional()
+}).strict();
+var permissionedAgentCustomConnectorUpdateSchema = agentCustomConnectorGrantsSchema.extend({
+  operation: external_exports.enum(["replace", "add", "remove"]).optional()
+}).strict();
+var agentCustomConnectorUpdateSchema = external_exports.union([
+  legacyAgentCustomConnectorUpdateSchema,
+  permissionedAgentCustomConnectorUpdateSchema
+]);
+var zeroAgentCustomConnectorsContract = c4.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/custom-connectors",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: agentCustomConnectorResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get enabled custom connector ids for user on agent"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id/custom-connectors",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: agentCustomConnectorUpdateSchema,
+    responses: {
+      200: agentCustomConnectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Update enabled custom connector ids for user on agent"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-connectors.ts
+init_esm_shims();
+var c5 = initContract();
+var zeroConnectorsMainContract = c5.router({
+  list: {
+    method: "GET",
+    path: "/api/zero/connectors",
+    headers: authHeadersSchema,
+    responses: {
+      200: connectorListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List all connectors (zero proxy)"
+  }
+});
+var zeroConnectorsBySlugContract = c5.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/connectors/:connectorSlug",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    responses: {
+      200: connectorResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get connector by slug (zero proxy)"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/connectors/:connectorSlug",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    responses: {
+      204: c5.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Disconnect a connector (zero proxy)"
+  }
+});
+var zeroConnectorScopeDiffContract = c5.router({
+  getScopeDiff: {
+    method: "GET",
+    path: "/api/zero/connectors/:connectorSlug/scope-diff",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    responses: {
+      200: scopeDiffResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get scope diff for a connector"
+  }
+});
+var zeroConnectorOauthStartContract = c5.router({
+  start: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/oauth/start",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional(),
+      callbackTarget: external_exports.literal("app").optional()
+    }),
+    responses: {
+      200: connectorOauthStartResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create connector OAuth authorization URL"
+  }
+});
+var zeroConnectorOauthContinueContract = c5.router({
+  continue: {
+    method: "GET",
+    path: "/api/zero/connectors/:connectorSlug/oauth/continue",
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    query: external_exports.object({ state: external_exports.string().regex(/^[0-9a-f]{64}$/) }),
+    responses: {
+      307: c5.noBody(),
+      400: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Continue connector OAuth in the browser"
+  }
+});
+var zeroConnectorOpenIdStartContract = c5.router({
+  start: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/openid/start",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional()
+    }),
+    responses: {
+      200: connectorOauthStartResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create connector OpenID handoff and authorization URL"
+  }
+});
+var zeroConnectorManualGrantContract = c5.router({
+  connect: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/manual-grant",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional(),
+      values: external_exports.record(external_exports.string(), external_exports.string())
+    }),
+    responses: {
+      200: connectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Connect a connector with a manual grant"
+  }
+});
+var zeroConnectorNoAuthGrantContract = c5.router({
+  connect: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/no-auth",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional()
+    }),
+    responses: {
+      200: connectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Enable a connector with a no-auth grant"
+  }
+});
+var zeroConnectorOauthDeviceAuthSessionContract = c5.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/oauth/device/sessions",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional(),
+      options: external_exports.record(external_exports.string(), external_exports.string()).optional()
+    }),
+    responses: {
+      200: connectorOauthDeviceAuthSessionStartResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create connector OAuth device authorization session"
+  },
+  poll: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/oauth/device/sessions/:sessionId/poll",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({
+      connectorSlug: connectorSlugSchema,
+      sessionId: external_exports.uuid()
+    }),
+    body: connectorOauthDeviceAuthSessionPollRequestSchema,
+    responses: {
+      200: connectorOauthDeviceAuthSessionPollResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Poll connector OAuth device authorization session"
+  }
+});
+var zeroConnectorExternalCodeSessionContract = c5.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/external-code/sessions",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    body: external_exports.object({
+      authMethod: connectorAuthMethodIdSchema,
+      agentId: external_exports.uuid().optional(),
+      authorizeAgent: external_exports.literal(true).optional()
+    }),
+    responses: {
+      200: connectorExternalCodeSessionStartResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create connector external-code authorization session"
+  },
+  complete: {
+    method: "POST",
+    path: "/api/zero/connectors/:connectorSlug/external-code/sessions/:sessionId/complete",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({
+      connectorSlug: connectorSlugSchema,
+      sessionId: external_exports.uuid()
+    }),
+    body: connectorExternalCodeSessionCompleteRequestSchema,
+    responses: {
+      200: connectorExternalCodeSessionCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Complete connector external-code authorization session"
+  }
+});
+var connectorSearchItemSchema = external_exports.object({
+  slug: connectorSlugSchema,
+  label: external_exports.string(),
+  description: external_exports.string(),
+  authMethods: external_exports.array(connectorAuthMethodIdSchema)
+});
+var connectorSearchResponseSchema = external_exports.object({
+  connectors: external_exports.array(connectorSearchItemSchema)
+});
+var zeroConnectorsSearchContract = c5.router({
+  search: {
+    method: "GET",
+    path: "/api/zero/connectors/search",
+    headers: authHeadersSchema,
+    query: external_exports.object({ keyword: external_exports.string().optional() }),
+    responses: {
+      200: connectorSearchResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      503: apiErrorSchema
+    },
+    summary: "Search available connectors by slug"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-connector-check.ts
+init_esm_shims();
+var c6 = initContract();
+var boundedNameSchema = external_exports.string().min(1).max(255);
+var connectorCheckUrlRequestSchema = external_exports.object({
+  mode: external_exports.literal("url"),
+  method: external_exports.string().min(1).max(16),
+  url: external_exports.string().min(1).max(8192),
+  connectorSlug: connectorSlugSchema.optional(),
+  environmentName: boundedNameSchema.optional()
+}).strict();
+var connectorCheckEnvironmentRequestSchema = external_exports.object({
+  mode: external_exports.literal("environment"),
+  environmentName: boundedNameSchema,
+  permission: boundedNameSchema.optional()
+}).strict();
+var connectorCheckRequestSchema = external_exports.discriminatedUnion("mode", [
+  connectorCheckUrlRequestSchema,
+  connectorCheckEnvironmentRequestSchema
+]);
+var connectorCheckIdentitySchema = external_exports.object({
+  connectorSlug: connectorSlugSchema,
+  label: external_exports.string().min(1),
+  visibility: external_exports.enum(["available", "unavailable"]),
+  credentialResolution: external_exports.enum(["network-boundary", "none"])
+});
+var connectorCheckCandidateSchema = external_exports.object({
+  connectorSlug: connectorSlugSchema,
+  label: external_exports.string().min(1)
+});
+var connectorCheckNotScopedRunSchema = external_exports.object({ status: external_exports.literal("not-scoped") }).strict();
+var connectorCheckConfiguredRunSchema = external_exports.object({
+  status: external_exports.literal("configured"),
+  bases: external_exports.array(external_exports.string().min(1))
+}).strict();
+var connectorCheckNotConfiguredRunSchema = external_exports.object({ status: external_exports.literal("not-configured") }).strict();
+var connectorCheckRunSchema = external_exports.discriminatedUnion("status", [
+  connectorCheckNotScopedRunSchema,
+  connectorCheckConfiguredRunSchema,
+  connectorCheckNotConfiguredRunSchema
+]);
+var connectorCheckAllowPolicySchema = external_exports.object({
+  outcome: external_exports.literal("allow"),
+  basis: external_exports.enum(["allow-list", "not-blocked", "no-policy", "unknown-policy"])
+}).strict();
+var connectorCheckDenyPolicySchema = external_exports.object({
+  outcome: external_exports.literal("deny"),
+  basis: external_exports.enum(["deny-list", "unknown-policy"])
+}).strict();
+var connectorCheckAskPolicySchema = external_exports.object({
+  outcome: external_exports.literal("ask"),
+  basis: external_exports.enum(["ask-list", "unknown-policy"])
+}).strict();
+var connectorCheckUnavailablePolicySchema = external_exports.object({
+  outcome: external_exports.literal("unavailable"),
+  basis: external_exports.enum([
+    "not-run-scoped",
+    "policies-unavailable",
+    "connector-not-configured"
+  ])
+}).strict();
+var connectorCheckPolicySchema = external_exports.discriminatedUnion("outcome", [
+  connectorCheckAllowPolicySchema,
+  connectorCheckDenyPolicySchema,
+  connectorCheckAskPolicySchema,
+  connectorCheckUnavailablePolicySchema
+]);
+var connectorCheckMatchedPermissionSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  policy: connectorCheckPolicySchema
+}).strict();
+var connectorCheckMatchedPermissionsSchema = external_exports.object({
+  kind: external_exports.literal("matched"),
+  permissions: external_exports.array(connectorCheckMatchedPermissionSchema).min(1)
+}).strict();
+var connectorCheckUnknownEndpointSchema = external_exports.object({
+  kind: external_exports.literal("unknown-endpoint"),
+  policy: connectorCheckPolicySchema
+}).strict();
+var connectorCheckPermissionResultSchema = external_exports.discriminatedUnion("kind", [
+  connectorCheckMatchedPermissionsSchema,
+  connectorCheckUnknownEndpointSchema
+]);
+var connectorCheckResolvedUrlSchema = external_exports.object({
+  outcome: external_exports.literal("resolved"),
+  mode: external_exports.literal("url"),
+  connector: connectorCheckIdentitySchema,
+  environmentNames: external_exports.array(boundedNameSchema).nullable(),
+  run: connectorCheckRunSchema,
+  method: external_exports.string().min(1).max(16),
+  base: external_exports.string().min(1),
+  relativePath: external_exports.string().min(1),
+  permission: connectorCheckPermissionResultSchema
+}).strict();
+var connectorCheckResolvedEnvironmentSchema = external_exports.object({
+  outcome: external_exports.literal("resolved"),
+  mode: external_exports.literal("environment"),
+  connector: connectorCheckIdentitySchema,
+  environmentName: boundedNameSchema,
+  run: connectorCheckRunSchema,
+  permission: connectorCheckPolicySchema.nullable()
+}).strict();
+var connectorCheckUnsafeInputSchema = external_exports.object({
+  outcome: external_exports.literal("unsafe-input"),
+  reason: external_exports.enum(["invalid-method", "invalid-url", "unsafe-path"])
+}).strict();
+var connectorCheckUnknownConnectorSchema = external_exports.object({ outcome: external_exports.literal("unknown-connector") }).strict();
+var connectorCheckUnknownEnvironmentSchema = external_exports.object({ outcome: external_exports.literal("unknown-environment") }).strict();
+var connectorCheckNoMatchSchema = external_exports.object({
+  outcome: external_exports.literal("no-match"),
+  scope: external_exports.enum(["run", "catalog"])
+}).strict();
+var connectorCheckAmbiguousSchema = external_exports.object({
+  outcome: external_exports.literal("ambiguous"),
+  candidates: external_exports.array(connectorCheckCandidateSchema).min(2)
+}).strict();
+var connectorCheckMismatchSchema = external_exports.object({
+  outcome: external_exports.literal("connector-mismatch"),
+  connector: connectorCheckIdentitySchema
+}).strict();
+var connectorCheckEnvironmentNotOwnedSchema = external_exports.object({
+  outcome: external_exports.literal("environment-not-owned"),
+  connector: connectorCheckIdentitySchema
+}).strict();
+var connectorCheckEnvironmentNotUsedSchema = external_exports.object({
+  outcome: external_exports.literal("environment-not-used"),
+  connector: connectorCheckIdentitySchema,
+  environmentNames: external_exports.array(boundedNameSchema)
+}).strict();
+var connectorCheckUnresolvedDynamicBaseSchema = external_exports.object({
+  outcome: external_exports.literal("unresolved-dynamic-base"),
+  connector: connectorCheckIdentitySchema
+}).strict();
+var connectorCheckRunContextUnavailableSchema = external_exports.object({ outcome: external_exports.literal("run-context-unavailable") }).strict();
+var connectorCheckDiagnosticResultSchema = external_exports.union([
+  connectorCheckResolvedUrlSchema,
+  connectorCheckResolvedEnvironmentSchema,
+  connectorCheckUnsafeInputSchema,
+  connectorCheckUnknownConnectorSchema,
+  connectorCheckUnknownEnvironmentSchema,
+  connectorCheckNoMatchSchema,
+  connectorCheckAmbiguousSchema,
+  connectorCheckMismatchSchema,
+  connectorCheckEnvironmentNotOwnedSchema,
+  connectorCheckEnvironmentNotUsedSchema,
+  connectorCheckUnresolvedDynamicBaseSchema,
+  connectorCheckRunContextUnavailableSchema
+]);
+var zeroConnectorCheckContract = c6.router({
+  check: {
+    method: "POST",
+    path: "/api/zero/connectors/diagnostics/check",
+    headers: authHeadersSchema,
+    body: connectorCheckRequestSchema,
+    responses: {
+      200: connectorCheckDiagnosticResultSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Resolve connector runtime diagnostics"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-custom-connectors.ts
+init_esm_shims();
+
+// ../../packages/api-contracts/src/contracts/connectors-slug-callback.ts
+init_esm_shims();
+var c7 = initContract();
+var connectorOauthCallbackResultSchema = external_exports.discriminatedUnion(
+  "status",
+  [
+    external_exports.object({
+      status: external_exports.literal("success"),
+      username: external_exports.string().nullable()
+    }),
+    external_exports.object({
+      status: external_exports.literal("error"),
+      message: external_exports.string()
+    })
+  ]
+);
+var connectorsSlugCallbackContract = c7.router({
+  callback: {
+    method: "GET",
+    path: "/api/connectors/:connectorSlug/callback",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ connectorSlug: connectorSlugSchema }),
+    query: external_exports.object({
+      code: external_exports.string().optional(),
+      auth_code: external_exports.string().optional(),
+      state: external_exports.string().optional(),
+      realmId: external_exports.string().optional(),
+      error: external_exports.string().optional(),
+      error_description: external_exports.string().optional(),
+      responseMode: external_exports.literal("json").optional(),
+      "openid.mode": external_exports.string().optional(),
+      "openid.ns": external_exports.string().optional(),
+      "openid.op_endpoint": external_exports.string().optional(),
+      "openid.claimed_id": external_exports.string().optional(),
+      "openid.identity": external_exports.string().optional(),
+      "openid.return_to": external_exports.string().optional(),
+      "openid.response_nonce": external_exports.string().optional(),
+      "openid.assoc_handle": external_exports.string().optional(),
+      "openid.signed": external_exports.string().optional(),
+      "openid.sig": external_exports.string().optional(),
+      "openid.realm": external_exports.string().optional()
+    }).catchall(external_exports.string()),
+    responses: {
+      200: connectorOauthCallbackResultSchema,
+      307: c7.noBody()
+    },
+    summary: "Complete connector browser authorization"
+  }
+});
+
+// ../../packages/api-contracts/src/contracts/zero-custom-connectors.ts
+var c8 = initContract();
+var customConnectorFieldKindSchema = external_exports.enum(["secret", "variable"]);
+var customConnectorFieldSchema = external_exports.object({
+  key: external_exports.string().min(1).max(64),
+  label: external_exports.string().min(1).max(128),
+  kind: customConnectorFieldKindSchema,
+  required: external_exports.boolean(),
+  description: external_exports.string().max(512).optional()
+});
+var customConnectorHeaderInjectionSchema = external_exports.object({
+  name: external_exports.string().min(1).max(128),
+  valueTemplate: external_exports.string().min(1).max(2048)
+});
+var customConnectorQueryInjectionSchema = external_exports.object({
+  name: external_exports.string().min(1).max(128),
+  valueTemplate: external_exports.string().min(1).max(2048)
+});
+var customConnectorAuthModeSchema = external_exports.enum(["manual", "oauth"]);
+var customConnectorOAuthProviderAdapterSchema = external_exports.enum([
+  "standard",
+  "feishu"
+]);
+var customConnectorOAuthTokenEndpointAuthMethodSchema = external_exports.enum([
+  "client_secret_basic",
+  "client_secret_post"
+]);
+var customConnectorOAuthPkceMethodSchema = external_exports.enum(["none", "S256"]);
+var customConnectorOAuthConfigSchema = external_exports.object({
+  providerAdapter: customConnectorOAuthProviderAdapterSchema,
+  clientId: external_exports.string().min(1).max(255),
+  authorizationUrl: external_exports.string().url().max(2048),
+  tokenUrl: external_exports.string().url().max(2048),
+  tokenEndpointAuthMethod: customConnectorOAuthTokenEndpointAuthMethodSchema,
+  pkceMethod: customConnectorOAuthPkceMethodSchema,
+  scopes: external_exports.array(external_exports.string().min(1).max(256)).max(100),
+  authorizationParams: external_exports.record(external_exports.string(), external_exports.string())
+});
+var customConnectorOAuthConfigInputSchema = customConnectorOAuthConfigSchema.extend({
+  clientSecret: external_exports.string().min(1).max(4096).optional()
+});
+var customConnectorPermissionBundleRefSchema = external_exports.string().max(128).regex(/^builtin:[a-z0-9][a-z0-9-]*@1$/u);
+var customConnectorPermissionSchema = external_exports.object({
+  name: external_exports.string().min(1).max(128),
+  description: external_exports.string().optional()
+});
+var customConnectorPermissionBundleSchema = external_exports.object({
+  ref: customConnectorPermissionBundleRefSchema,
+  permissions: external_exports.array(customConnectorPermissionSchema),
+  defaultPolicies: external_exports.record(external_exports.string(), external_exports.enum(["allow", "deny", "ask"]))
+});
+var customConnectorSkillMarkdownSchema = external_exports.string().refine(
+  (value) => {
+    return new TextEncoder().encode(value).byteLength <= 65536;
+  },
+  { message: "Custom connector skill markdown must not exceed 64 KiB" }
+);
+var customConnectorResponseSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  slug: external_exports.string(),
+  displayName: external_exports.string(),
+  prefixes: external_exports.array(external_exports.string()),
+  headerName: external_exports.string(),
+  headerTemplate: external_exports.string(),
+  prefixTemplates: external_exports.array(external_exports.string()),
+  fields: external_exports.array(customConnectorFieldSchema),
+  headerInjections: external_exports.array(customConnectorHeaderInjectionSchema),
+  queryInjections: external_exports.array(customConnectorQueryInjectionSchema),
+  authMode: customConnectorAuthModeSchema.optional(),
+  oauthConfig: customConnectorOAuthConfigSchema.optional(),
+  permissionBundleRef: customConnectorPermissionBundleRefSchema.nullable().optional(),
+  skillMarkdown: customConnectorSkillMarkdownSchema.nullable().optional(),
+  revision: external_exports.number().int().positive().optional(),
+  connected: external_exports.boolean(),
+  missingRequiredFields: external_exports.array(external_exports.string()),
+  configuredFieldKeys: external_exports.array(external_exports.string()),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  hasSecret: external_exports.boolean()
+});
+var customConnectorListResponseSchema = external_exports.object({
+  connectors: external_exports.array(customConnectorResponseSchema)
+});
+var createCustomConnectorBodySchema = external_exports.object({
+  displayName: external_exports.string().min(1).max(128),
+  prefixes: external_exports.array(external_exports.string().min(1)).min(1).optional(),
+  headerName: external_exports.string().min(1).max(128).optional(),
+  headerTemplate: external_exports.string().min(1).optional(),
+  prefixTemplates: external_exports.array(external_exports.string().min(1)).min(1).optional(),
+  fields: external_exports.array(customConnectorFieldSchema).optional(),
+  headerInjections: external_exports.array(customConnectorHeaderInjectionSchema).optional(),
+  queryInjections: external_exports.array(customConnectorQueryInjectionSchema).optional(),
+  authMode: customConnectorAuthModeSchema.optional(),
+  oauthConfig: customConnectorOAuthConfigInputSchema.optional(),
+  permissionBundleRef: customConnectorPermissionBundleRefSchema.nullable().optional(),
+  skillMarkdown: customConnectorSkillMarkdownSchema.nullable().optional(),
+  slug: external_exports.string().optional()
+});
+var updateCustomConnectorBodySchema = external_exports.object({
+  displayName: external_exports.string().min(1).max(128),
+  prefixTemplates: external_exports.array(external_exports.string().min(1)).min(1),
+  fields: external_exports.array(customConnectorFieldSchema),
+  headerInjections: external_exports.array(customConnectorHeaderInjectionSchema),
+  queryInjections: external_exports.array(customConnectorQueryInjectionSchema),
+  authMode: customConnectorAuthModeSchema.optional(),
+  oauthConfig: customConnectorOAuthConfigInputSchema.optional(),
+  permissionBundleRef: customConnectorPermissionBundleRefSchema.nullable().optional(),
+  skillMarkdown: customConnectorSkillMarkdownSchema.nullable().optional()
+});
+var setCustomConnectorSecretBodySchema = external_exports.object({
+  value: external_exports.string().min(1)
+});
+var startCustomConnectorOAuth2BodySchema = external_exports.object({
+  agentId: external_exports.string().uuid().optional()
+}).strict();
+var startCustomConnectorOAuth2ResponseSchema = external_exports.object({
+  authorizationUrl: external_exports.string().url()
+});
+var customConnectorValueInputSchema = external_exports.object({
+  key: external_exports.string().min(1).max(64),
+  kind: customConnectorFieldKindSchema,
+  value: external_exports.string().min(1)
+});
+var setCustomConnectorValuesBodySchema = external_exports.object({
+  values: external_exports.array(customConnectorValueInputSchema)
+});
+var patchCustomConnectorBodySchema = external_exports.object({
+  displayName: external_exports.string().min(1).max(128)
+});
+var customConnectorProposalSchema = external_exports.object({
+  operation: external_exports.enum(["create", "update"]),
+  connectorId: external_exports.string().uuid().optional(),
+  displayName: external_exports.string().min(1).max(128),
+  prefixTemplates: external_exports.array(external_exports.string().min(1)).min(1),
+  fields: external_exports.array(customConnectorFieldSchema),
+  headerInjections: external_exports.array(customConnectorHeaderInjectionSchema),
+  queryInjections: external_exports.array(customConnectorQueryInjectionSchema),
+  notes: external_exports.string().max(2048).optional()
+});
+var saveCustomConnectorProposalBodySchema = external_exports.object({
+  proposal: customConnectorProposalSchema,
+  values: external_exports.array(customConnectorValueInputSchema),
+  agentId: external_exports.string().uuid().optional()
+});
+var saveCustomConnectorProposalResponseSchema = external_exports.object({
+  connector: customConnectorResponseSchema,
+  authorizedAgentId: external_exports.string().uuid().optional()
+});
+var zeroCustomConnectorsContract = c8.router({
+  list: {
+    method: "GET",
+    path: "/api/zero/custom-connectors",
+    headers: authHeadersSchema,
+    responses: {
+      200: customConnectorListResponseSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List org custom connectors"
+  },
+  create: {
+    method: "POST",
+    path: "/api/zero/custom-connectors",
+    headers: authHeadersSchema,
+    body: createCustomConnectorBodySchema,
+    responses: {
+      201: customConnectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create an org custom connector"
+  }
+});
+var zeroCustomConnectorByIdContract = c8.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/custom-connectors/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: customConnectorResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get an org custom connector"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/custom-connectors/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      204: c8.noBody(),
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Delete an org custom connector"
+  },
+  patch: {
+    method: "PATCH",
+    path: "/api/zero/custom-connectors/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: patchCustomConnectorBodySchema,
+    responses: {
+      200: customConnectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Rename an org custom connector"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/custom-connectors/:id",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: updateCustomConnectorBodySchema,
+    responses: {
+      200: customConnectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Update an org custom connector"
+  },
+  permissions: {
+    method: "GET",
+    path: "/api/zero/custom-connectors/:id/permissions",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      200: customConnectorPermissionBundleSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get an org custom connector permission bundle"
+  }
+});
+var zeroCustomConnectorSecretContract = c8.router({
+  set: {
+    method: "PUT",
+    path: "/api/zero/custom-connectors/:id/secret",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: setCustomConnectorSecretBodySchema,
+    responses: {
+      204: c8.noBody(),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Set the calling user's secret for a custom connector"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/custom-connectors/:id/secret",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    responses: {
+      204: c8.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Clear the calling user's secret for a custom connector"
+  }
+});
+var zeroCustomConnectorValuesContract = c8.router({
+  set: {
+    method: "PUT",
+    path: "/api/zero/custom-connectors/:id/values",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: setCustomConnectorValuesBodySchema,
+    responses: {
+      200: customConnectorResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Set the calling user's values for a custom connector"
+  }
+});
+var zeroCustomConnectorOAuth2Contract = c8.router({
+  start: {
+    method: "POST",
+    path: "/api/zero/custom-connectors/:id/oauth2/start",
+    headers: authHeadersSchema,
+    pathParams: external_exports.object({ id: external_exports.string().uuid() }),
+    body: startCustomConnectorOAuth2BodySchema,
+    responses: {
+      200: startCustomConnectorOAuth2ResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Start OAuth 2.0 for a custom connector"
+  },
+  callback: {
+    method: "GET",
+    path: "/api/zero/custom-connectors/oauth2/callback",
+    query: external_exports.object({
+      code: external_exports.string().optional(),
+      state: external_exports.string().optional(),
+      error: external_exports.string().optional(),
+      error_description: external_exports.string().optional(),
+      responseMode: external_exports.literal("json").optional()
+    }).catchall(external_exports.string()),
+    responses: {
+      200: connectorOauthCallbackResultSchema,
+      307: c8.noBody()
+    },
+    summary: "Complete OAuth 2.0 for a custom connector"
+  }
+});
+var zeroCustomConnectorProposalContract = c8.router({
+  save: {
+    method: "POST",
+    path: "/api/zero/custom-connectors/proposals/save",
+    headers: authHeadersSchema,
+    body: saveCustomConnectorProposalBodySchema,
+    responses: {
+      200: saveCustomConnectorProposalResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Save a custom connector proposal"
+  }
+});
+
+export {
+  zeroAgentVisibilitySchema,
+  zeroAgentsMainContract,
+  zeroAgentsByIdContract,
+  zeroAgentInstructionsContract,
+  zeroUserPermissionGrantsContract,
+  zeroUserConnectorsContract,
+  zeroAgentCustomConnectorsContract,
+  zeroConnectorsMainContract,
+  zeroConnectorsBySlugContract,
+  zeroConnectorManualGrantContract,
+  zeroConnectorCheckContract,
+  customConnectorAuthModeSchema,
+  customConnectorOAuthConfigInputSchema,
+  updateCustomConnectorBodySchema,
+  customConnectorValueInputSchema,
+  zeroCustomConnectorsContract,
+  zeroCustomConnectorByIdContract,
+  zeroCustomConnectorValuesContract,
+  zeroCustomConnectorOAuth2Contract
+};
+//# sourceMappingURL=chunk-HZYOJTEE.js.map