@vm0/cli 9.87.0 → 9.88.0

package/{chunk-JOVCRTRX.js → chunk-NM4FYPVK.js}

@@ -47,7 +47,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.87.0",
+    release: "9.88.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -66,7 +66,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.87.0",
+    version: "9.88.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -476,7 +476,7 @@ var agentDefinitionSchema = z3.object({
   experimental_runner: z3.object({
     group: z3.string().regex(
       /^[a-z0-9-]+\/[a-z0-9-]+$/,
-      "Runner group must be in org/name format (e.g., acme/production)"
+      "Runner group must be in vm0/<name> format (e.g., vm0/production)"
     )
   }).optional(),
   /**
@@ -2819,23 +2819,6 @@ var chatThreadByIdContract = c10.router({
     summary: "Get chat thread detail with messages"
   }
 });
-var chatThreadRunsContract = c10.router({
-  addRun: {
-    method: "POST",
-    path: "/api/zero/chat-threads/:id/runs",
-    headers: authHeadersSchema,
-    pathParams: z17.object({ id: z17.string() }),
-    body: z17.object({
-      runId: z17.string().min(1)
-    }),
-    responses: {
-      204: c10.noBody(),
-      401: apiErrorSchema,
-      404: apiErrorSchema
-    },
-    summary: "Associate a run to a chat thread"
-  }
-});
 var chatMessagesContract = c10.router({
   send: {
     method: "POST",
@@ -3007,7 +2990,7 @@ import { z as z19 } from "zod";
 var c12 = initContract();
 var runnerGroupSchema = z19.string().regex(
   /^[a-z0-9-]+\/[a-z0-9-]+$/,
-  "Runner group must be in org/name format (e.g., acme/production)"
+  "Runner group must be in vm0/<name> format (e.g., vm0/production)"
 );
 var jobSchema = z19.object({
   runId: z19.uuid(),
@@ -5582,7 +5565,8 @@ var CONNECTOR_TYPES_DEF = {
   mailchimp: {
     label: "Mailchimp",
     environmentMapping: {
-      MAILCHIMP_TOKEN: "$secrets.MAILCHIMP_ACCESS_TOKEN"
+      MAILCHIMP_TOKEN: "$secrets.MAILCHIMP_ACCESS_TOKEN",
+      MAILCHIMP_DC: "$vars.MAILCHIMP_DC"
     },
     featureFlag: "mailchimpConnector" /* MailchimpConnector */,
     helpText: "Connect your Mailchimp account to manage audiences, campaigns, templates, and automations",
@@ -5594,6 +5578,13 @@ var CONNECTOR_TYPES_DEF = {
             label: "API Key",
             required: true,
             placeholder: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-us00"
+          },
+          MAILCHIMP_DC: {
+            label: "Server Prefix",
+            required: true,
+            type: "variable",
+            placeholder: "us21",
+            helpText: "The datacenter prefix from your API key (e.g., 'us21' from xxxxx-us21)"
           }
         }
       }
@@ -5604,7 +5595,8 @@ var CONNECTOR_TYPES_DEF = {
       tokenUrl: "https://login.mailchimp.com/oauth2/token",
       scopes: [],
       environmentMapping: {
-        MAILCHIMP_TOKEN: "$secrets.MAILCHIMP_ACCESS_TOKEN"
+        MAILCHIMP_TOKEN: "$secrets.MAILCHIMP_ACCESS_TOKEN",
+        MAILCHIMP_DC: "$vars.MAILCHIMP_DC"
       }
     }
   },
@@ -13351,6 +13343,26 @@ var loopsFirewall = {
   ]
 };
 
+// ../../packages/core/src/firewalls/mailchimp.generated.ts
+var mailchimpFirewall = {
+  name: "mailchimp",
+  description: "Mailchimp Marketing API",
+  placeholders: {
+    MAILCHIMP_TOKEN: "ae54fcc23ade65fa404a65e78c56f898-us6"
+  },
+  apis: [
+    {
+      base: "https://${{ vars.MAILCHIMP_DC }}.api.mailchimp.com",
+      auth: {
+        headers: {
+          Authorization: "Bearer ${{ secrets.MAILCHIMP_TOKEN }}"
+        }
+      },
+      permissions: []
+    }
+  ]
+};
+
 // ../../packages/core/src/firewalls/make.generated.ts
 var makeFirewall = {
   name: "make",
@@ -13456,6 +13468,26 @@ var mercuryFirewall = {
   ]
 };
 
+// ../../packages/core/src/firewalls/metabase.generated.ts
+var metabaseFirewall = {
+  name: "metabase",
+  description: "Metabase API",
+  placeholders: {
+    METABASE_TOKEN: "mb_Vm0PlaceHolder00000000000000000000000000000"
+  },
+  apis: [
+    {
+      base: "${{ vars.METABASE_BASE_URL }}",
+      auth: {
+        headers: {
+          "x-api-key": "${{ secrets.METABASE_TOKEN }}"
+        }
+      },
+      permissions: []
+    }
+  ]
+};
+
 // ../../packages/core/src/firewalls/meta-ads.generated.ts
 var metaAdsFirewall = {
   name: "meta-ads",
@@ -13898,6 +13930,26 @@ var pushinatorFirewall = {
   ]
 };
 
+// ../../packages/core/src/firewalls/qdrant.generated.ts
+var qdrantFirewall = {
+  name: "qdrant",
+  description: "Qdrant Vector Database API",
+  placeholders: {
+    QDRANT_TOKEN: "Vm0PlaceHolder0000000000000000000000000000"
+  },
+  apis: [
+    {
+      base: "${{ vars.QDRANT_BASE_URL }}",
+      auth: {
+        headers: {
+          "api-key": "${{ secrets.QDRANT_TOKEN }}"
+        }
+      },
+      permissions: []
+    }
+  ]
+};
+
 // ../../packages/core/src/firewalls/qiita.generated.ts
 var qiitaFirewall = {
   name: "qiita",
@@ -14018,6 +14070,26 @@ var runwayFirewall = {
   ]
 };
 
+// ../../packages/core/src/firewalls/salesforce.generated.ts
+var salesforceFirewall = {
+  name: "salesforce",
+  description: "Salesforce REST API",
+  placeholders: {
+    SALESFORCE_TOKEN: "00D0x000000Vm0P!AQEAQFVm0PlaceHolder0000000000000000000000000000000000000000000000000000000000000000000"
+  },
+  apis: [
+    {
+      base: "https://${{ vars.SALESFORCE_INSTANCE }}.my.salesforce.com",
+      auth: {
+        headers: {
+          Authorization: "Bearer ${{ secrets.SALESFORCE_TOKEN }}"
+        }
+      },
+      permissions: []
+    }
+  ]
+};
+
 // ../../packages/core/src/firewalls/scrapeninja.generated.ts
 var scrapeninjaFirewall = {
   name: "scrapeninja",
@@ -16293,9 +16365,11 @@ var CONNECTOR_FIREWALLS = {
   line: lineFirewall,
   linear: linearFirewall,
   loops: loopsFirewall,
+  mailchimp: mailchimpFirewall,
   make: makeFirewall,
   mailsac: mailsacFirewall,
   mercury: mercuryFirewall,
+  metabase: metabaseFirewall,
   "meta-ads": metaAdsFirewall,
   minimax: minimaxFirewall,
   monday: mondayFirewall,
@@ -16314,12 +16388,14 @@ var CONNECTOR_FIREWALLS = {
   "prisma-postgres": prismaPostgresFirewall,
   productlane: productlaneFirewall,
   pushinator: pushinatorFirewall,
+  qdrant: qdrantFirewall,
   qiita: qiitaFirewall,
   reddit: redditFirewall,
   reportei: reporteiFirewall,
   resend: resendFirewall,
   revenuecat: revenuecatFirewall,
   runway: runwayFirewall,
+  salesforce: salesforceFirewall,
   scrapeninja: scrapeninjaFirewall,
   sentry: sentryFirewall,
   serpapi: serpapiFirewall,
@@ -16525,15 +16601,14 @@ var zeroAgentResponseSchema = z26.object({
   displayName: z26.string().nullable(),
   sound: z26.string().nullable(),
   avatarUrl: z26.string().nullable(),
-  connectors: z26.array(z26.string()),
-  firewallPolicies: firewallPoliciesSchema.nullable()
+  firewallPolicies: firewallPoliciesSchema.nullable(),
+  customSkills: z26.array(z26.string()).default([])
 });
 var zeroAgentRequestSchema = z26.object({
   description: z26.string().optional(),
   displayName: z26.string().optional(),
   sound: z26.string().optional(),
-  avatarUrl: z26.string().optional(),
-  connectors: z26.array(z26.string())
+  avatarUrl: z26.string().optional()
 });
 var zeroAgentMetadataRequestSchema = z26.object({
   displayName: z26.string().optional(),
@@ -16685,11 +16760,153 @@ var zeroAgentInstructionsContract = c17.router({
     summary: "Update zero agent instructions"
   }
 });
+var zeroAgentCustomSkillNameSchema = z26.string().min(2).max(64).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/);
+var zeroAgentCustomSkillSchema = z26.object({
+  name: zeroAgentCustomSkillNameSchema,
+  displayName: z26.string().max(256).nullable(),
+  description: z26.string().max(1024).nullable()
+});
+var zeroAgentSkillContentRequestSchema = z26.object({
+  content: z26.string()
+});
+var zeroAgentSkillContentResponseSchema = z26.object({
+  name: z26.string(),
+  displayName: z26.string().nullable(),
+  description: z26.string().nullable(),
+  content: z26.string().nullable()
+});
+var zeroAgentSkillListResponseSchema = z26.array(
+  zeroAgentCustomSkillSchema
+);
+var zeroAgentSkillsCollectionContract = c17.router({
+  list: {
+    method: "GET",
+    path: "/api/zero/agents/:id/skills",
+    headers: authHeadersSchema,
+    pathParams: z26.object({ id: z26.string().uuid() }),
+    responses: {
+      200: zeroAgentSkillListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "List custom skills for agent"
+  },
+  create: {
+    method: "POST",
+    path: "/api/zero/agents/:id/skills",
+    headers: authHeadersSchema,
+    pathParams: z26.object({ id: z26.string().uuid() }),
+    body: zeroAgentSkillContentRequestSchema.extend({
+      name: zeroAgentCustomSkillNameSchema,
+      displayName: z26.string().max(256).optional(),
+      description: z26.string().max(1024).optional()
+    }),
+    responses: {
+      201: zeroAgentCustomSkillSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create custom skill for agent"
+  }
+});
+var zeroAgentSkillsDetailContract = c17.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/skills/:name",
+    headers: authHeadersSchema,
+    pathParams: z26.object({
+      id: z26.string().uuid(),
+      name: zeroAgentCustomSkillNameSchema
+    }),
+    responses: {
+      200: zeroAgentSkillContentResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get custom skill with content"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id/skills/:name",
+    headers: authHeadersSchema,
+    pathParams: z26.object({
+      id: z26.string().uuid(),
+      name: zeroAgentCustomSkillNameSchema
+    }),
+    body: zeroAgentSkillContentRequestSchema,
+    responses: {
+      200: zeroAgentSkillContentResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Update custom skill content"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/agents/:id/skills/:name",
+    headers: authHeadersSchema,
+    pathParams: z26.object({
+      id: z26.string().uuid(),
+      name: zeroAgentCustomSkillNameSchema
+    }),
+    body: c17.noBody(),
+    responses: {
+      204: c17.noBody(),
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Delete custom skill"
+  }
+});
 
-// ../../packages/core/src/contracts/zero-connectors.ts
+// ../../packages/core/src/contracts/user-connectors.ts
 import { z as z27 } from "zod";
 var c18 = initContract();
-var zeroConnectorsMainContract = c18.router({
+var userConnectorEnabledTypesSchema = z27.object({
+  enabledTypes: z27.array(z27.string())
+});
+var zeroUserConnectorsContract = c18.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/agents/:id/user-connectors",
+    headers: authHeadersSchema,
+    pathParams: z27.object({ id: z27.string().uuid() }),
+    responses: {
+      200: userConnectorEnabledTypesSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get enabled connector types for user on agent"
+  },
+  update: {
+    method: "PUT",
+    path: "/api/zero/agents/:id/user-connectors",
+    headers: authHeadersSchema,
+    pathParams: z27.object({ id: z27.string().uuid() }),
+    body: userConnectorEnabledTypesSchema,
+    responses: {
+      200: userConnectorEnabledTypesSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Replace enabled connector types for user on agent"
+  }
+});
+
+// ../../packages/core/src/contracts/zero-connectors.ts
+import { z as z28 } from "zod";
+var c19 = initContract();
+var zeroConnectorsMainContract = c19.router({
   list: {
     method: "GET",
     path: "/api/zero/connectors",
@@ -16702,12 +16919,12 @@ var zeroConnectorsMainContract = c18.router({
     summary: "List all connectors (zero proxy)"
   }
 });
-var zeroConnectorsByTypeContract = c18.router({
+var zeroConnectorsByTypeContract = c19.router({
   get: {
     method: "GET",
     path: "/api/zero/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z27.object({ type: connectorTypeSchema }),
+    pathParams: z28.object({ type: connectorTypeSchema }),
     responses: {
       200: connectorResponseSchema,
       401: apiErrorSchema,
@@ -16719,21 +16936,21 @@ var zeroConnectorsByTypeContract = c18.router({
     method: "DELETE",
     path: "/api/zero/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z27.object({ type: connectorTypeSchema }),
+    pathParams: z28.object({ type: connectorTypeSchema }),
     responses: {
-      204: c18.noBody(),
+      204: c19.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Disconnect a connector (zero proxy)"
   }
 });
-var zeroConnectorScopeDiffContract = c18.router({
+var zeroConnectorScopeDiffContract = c19.router({
   getScopeDiff: {
     method: "GET",
     path: "/api/zero/connectors/:type/scope-diff",
     headers: authHeadersSchema,
-    pathParams: z27.object({ type: connectorTypeSchema }),
+    pathParams: z28.object({ type: connectorTypeSchema }),
     responses: {
       200: scopeDiffResponseSchema,
       401: apiErrorSchema,
@@ -16742,22 +16959,22 @@ var zeroConnectorScopeDiffContract = c18.router({
     summary: "Get scope diff for a connector"
   }
 });
-var connectorSearchAuthMethodSchema = z27.enum(["oauth", "api-token"]);
-var connectorSearchItemSchema = z27.object({
-  id: z27.string(),
-  label: z27.string(),
-  description: z27.string(),
-  authMethods: z27.array(connectorSearchAuthMethodSchema)
+var connectorSearchAuthMethodSchema = z28.enum(["oauth", "api-token"]);
+var connectorSearchItemSchema = z28.object({
+  id: z28.string(),
+  label: z28.string(),
+  description: z28.string(),
+  authMethods: z28.array(connectorSearchAuthMethodSchema)
 });
-var connectorSearchResponseSchema = z27.object({
-  connectors: z27.array(connectorSearchItemSchema)
+var connectorSearchResponseSchema = z28.object({
+  connectors: z28.array(connectorSearchItemSchema)
 });
-var zeroConnectorsSearchContract = c18.router({
+var zeroConnectorsSearchContract = c19.router({
   search: {
     method: "GET",
     path: "/api/zero/connectors/search",
     headers: authHeadersSchema,
-    query: z27.object({ keyword: z27.string().optional() }),
+    query: z28.object({ keyword: z28.string().optional() }),
     responses: {
       200: connectorSearchResponseSchema,
       401: apiErrorSchema
@@ -16765,13 +16982,13 @@ var zeroConnectorsSearchContract = c18.router({
     summary: "Search available connector types"
   }
 });
-var zeroConnectorSessionsContract = c18.router({
+var zeroConnectorSessionsContract = c19.router({
   create: {
     method: "POST",
     path: "/api/zero/connectors/:type/sessions",
     headers: authHeadersSchema,
-    pathParams: z27.object({ type: connectorTypeSchema }),
-    body: z27.object({}).optional(),
+    pathParams: z28.object({ type: connectorTypeSchema }),
+    body: z28.object({}).optional(),
     responses: {
       200: connectorSessionResponseSchema,
       400: apiErrorSchema,
@@ -16780,14 +16997,14 @@ var zeroConnectorSessionsContract = c18.router({
     summary: "Create connector session for device flow (zero proxy)"
   }
 });
-var zeroConnectorSessionByIdContract = c18.router({
+var zeroConnectorSessionByIdContract = c19.router({
   get: {
     method: "GET",
     path: "/api/zero/connectors/:type/sessions/:sessionId",
     headers: authHeadersSchema,
-    pathParams: z27.object({
+    pathParams: z28.object({
       type: connectorTypeSchema,
-      sessionId: z27.uuid()
+      sessionId: z28.uuid()
     }),
     responses: {
       200: connectorSessionStatusResponseSchema,
@@ -16798,12 +17015,12 @@ var zeroConnectorSessionByIdContract = c18.router({
     summary: "Get connector session status (zero proxy)"
   }
 });
-var zeroComputerConnectorContract = c18.router({
+var zeroComputerConnectorContract = c19.router({
   create: {
     method: "POST",
     path: "/api/zero/connectors/computer",
     headers: authHeadersSchema,
-    body: z27.object({}).optional(),
+    body: z28.object({}).optional(),
     responses: {
       200: computerConnectorCreateResponseSchema,
       400: apiErrorSchema,
@@ -16828,7 +17045,7 @@ var zeroComputerConnectorContract = c18.router({
     path: "/api/zero/connectors/computer",
     headers: authHeadersSchema,
     responses: {
-      204: c18.noBody(),
+      204: c19.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
@@ -16837,9 +17054,9 @@ var zeroComputerConnectorContract = c18.router({
 });
 
 // ../../packages/core/src/contracts/zero-org.ts
-import { z as z28 } from "zod";
-var c19 = initContract();
-var zeroOrgContract = c19.router({
+import { z as z29 } from "zod";
+var c20 = initContract();
+var zeroOrgContract = c20.router({
   get: {
     method: "GET",
     path: "/api/zero/org",
@@ -16868,12 +17085,12 @@ var zeroOrgContract = c19.router({
     summary: "Update org slug (zero proxy)"
   }
 });
-var zeroOrgLeaveContract = c19.router({
+var zeroOrgLeaveContract = c20.router({
   leave: {
     method: "POST",
     path: "/api/zero/org/leave",
     headers: authHeadersSchema,
-    body: z28.object({}),
+    body: z29.object({}),
     responses: {
       200: orgMessageResponseSchema,
       401: apiErrorSchema,
@@ -16883,12 +17100,12 @@ var zeroOrgLeaveContract = c19.router({
     summary: "Leave the current org (zero proxy)"
   }
 });
-var zeroOrgDeleteContract = c19.router({
+var zeroOrgDeleteContract = c20.router({
   delete: {
     method: "POST",
     path: "/api/zero/org/delete",
     headers: authHeadersSchema,
-    body: z28.object({ slug: z28.string() }),
+    body: z29.object({ slug: z29.string() }),
     responses: {
       200: orgMessageResponseSchema,
       400: apiErrorSchema,
@@ -16901,8 +17118,8 @@ var zeroOrgDeleteContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/zero-org-list.ts
-var c20 = initContract();
-var zeroOrgListContract = c20.router({
+var c21 = initContract();
+var zeroOrgListContract = c21.router({
   list: {
     method: "GET",
     path: "/api/zero/org/list",
@@ -16917,8 +17134,8 @@ var zeroOrgListContract = c20.router({
 });
 
 // ../../packages/core/src/contracts/zero-org-members.ts
-var c21 = initContract();
-var zeroOrgMembersContract = c21.router({
+var c22 = initContract();
+var zeroOrgMembersContract = c22.router({
   members: {
     method: "GET",
     path: "/api/zero/org/members",
@@ -16962,7 +17179,7 @@ var zeroOrgMembersContract = c21.router({
     summary: "Remove a member from the org (zero proxy)"
   }
 });
-var zeroOrgInviteContract = c21.router({
+var zeroOrgInviteContract = c22.router({
   invite: {
     method: "POST",
     path: "/api/zero/org/invite",
@@ -16992,7 +17209,7 @@ var zeroOrgInviteContract = c21.router({
     summary: "Revoke a pending invitation (zero proxy)"
   }
 });
-var zeroOrgMembershipRequestsContract = c21.router({
+var zeroOrgMembershipRequestsContract = c22.router({
   accept: {
     method: "POST",
     path: "/api/zero/org/membership-requests",
@@ -17024,8 +17241,8 @@ var zeroOrgMembershipRequestsContract = c21.router({
 });
 
 // ../../packages/core/src/contracts/zero-org-domains.ts
-var c22 = initContract();
-var zeroOrgDomainsContract = c22.router({
+var c23 = initContract();
+var zeroOrgDomainsContract = c23.router({
   list: {
     method: "GET",
     path: "/api/zero/org/domains",
@@ -17080,16 +17297,16 @@ var zeroOrgDomainsContract = c22.router({
 });
 
 // ../../packages/core/src/contracts/zero-composes.ts
-import { z as z29 } from "zod";
-var c23 = initContract();
-var zeroComposesMainContract = c23.router({
+import { z as z30 } from "zod";
+var c24 = initContract();
+var zeroComposesMainContract = c24.router({
   getByName: {
     method: "GET",
     path: "/api/zero/composes",
     headers: authHeadersSchema,
-    query: z29.object({
-      name: z29.string().min(1, "Missing name query parameter"),
-      org: z29.string().optional()
+    query: z30.object({
+      name: z30.string().min(1, "Missing name query parameter"),
+      org: z30.string().optional()
     }),
     responses: {
       200: composeResponseSchema,
@@ -17100,13 +17317,13 @@ var zeroComposesMainContract = c23.router({
     summary: "Get agent compose by name (zero proxy)"
   }
 });
-var zeroComposesByIdContract = c23.router({
+var zeroComposesByIdContract = c24.router({
   getById: {
     method: "GET",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z29.object({
-      id: z29.string().min(1, "Compose ID is required")
+    pathParams: z30.object({
+      id: z30.string().min(1, "Compose ID is required")
     }),
     responses: {
       200: composeResponseSchema,
@@ -17120,12 +17337,12 @@ var zeroComposesByIdContract = c23.router({
     method: "DELETE",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z29.object({
-      id: z29.string().uuid("Compose ID is required")
+    pathParams: z30.object({
+      id: z30.string().uuid("Compose ID is required")
     }),
-    body: c23.noBody(),
+    body: c24.noBody(),
     responses: {
-      204: c23.noBody(),
+      204: c24.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema,
@@ -17134,17 +17351,17 @@ var zeroComposesByIdContract = c23.router({
     summary: "Delete agent compose (zero proxy)"
   }
 });
-var zeroComposesListContract = c23.router({
+var zeroComposesListContract = c24.router({
   list: {
     method: "GET",
     path: "/api/zero/composes/list",
     headers: authHeadersSchema,
-    query: z29.object({
-      org: z29.string().optional()
+    query: z30.object({
+      org: z30.string().optional()
     }),
     responses: {
-      200: z29.object({
-        composes: z29.array(composeListItemSchema)
+      200: z30.object({
+        composes: z30.array(composeListItemSchema)
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -17155,7 +17372,7 @@ var zeroComposesListContract = c23.router({
 });
 
 // ../../packages/core/src/contracts/zero-runs.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   triggerSource: true,
   memoryName: true,
@@ -17167,10 +17384,10 @@ var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   secrets: true,
   agentComposeId: true
 }).extend({
-  agentId: z30.string().optional()
+  agentId: z31.string().optional()
 });
-var c24 = initContract();
-var zeroRunsMainContract = c24.router({
+var c25 = initContract();
+var zeroRunsMainContract = c25.router({
   create: {
     method: "POST",
     path: "/api/zero/runs",
@@ -17186,13 +17403,13 @@ var zeroRunsMainContract = c24.router({
     summary: "Create and execute agent run (zero proxy)"
   }
 });
-var zeroRunsByIdContract = c24.router({
+var zeroRunsByIdContract = c25.router({
   getById: {
     method: "GET",
     path: "/api/zero/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().min(1, "Run ID is required")
+    pathParams: z31.object({
+      id: z31.string().min(1, "Run ID is required")
     }),
     responses: {
       200: getRunResponseSchema,
@@ -17203,15 +17420,15 @@ var zeroRunsByIdContract = c24.router({
     summary: "Get agent run by ID (zero proxy)"
   }
 });
-var zeroRunsCancelContract = c24.router({
+var zeroRunsCancelContract = c25.router({
   cancel: {
     method: "POST",
     path: "/api/zero/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().min(1, "Run ID is required")
+    pathParams: z31.object({
+      id: z31.string().min(1, "Run ID is required")
     }),
-    body: z30.undefined(),
+    body: z31.undefined(),
     responses: {
       200: cancelRunResponseSchema,
       400: apiErrorSchema,
@@ -17222,7 +17439,7 @@ var zeroRunsCancelContract = c24.router({
     summary: "Cancel a pending or running run (zero proxy)"
   }
 });
-var zeroRunsQueueContract = c24.router({
+var zeroRunsQueueContract = c25.router({
   getQueue: {
     method: "GET",
     path: "/api/zero/runs/queue",
@@ -17235,18 +17452,18 @@ var zeroRunsQueueContract = c24.router({
     summary: "Get org run queue status (zero proxy)"
   }
 });
-var zeroRunAgentEventsContract = c24.router({
+var zeroRunAgentEventsContract = c25.router({
   getAgentEvents: {
     method: "GET",
     path: "/api/zero/runs/:id/telemetry/agent",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().min(1, "Run ID is required")
+    pathParams: z31.object({
+      id: z31.string().min(1, "Run ID is required")
     }),
-    query: z30.object({
-      since: z30.coerce.number().optional(),
-      limit: z30.coerce.number().min(1).max(100).default(5),
-      order: z30.enum(["asc", "desc"]).default("desc")
+    query: z31.object({
+      since: z31.coerce.number().optional(),
+      limit: z31.coerce.number().min(1).max(100).default(5),
+      order: z31.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: agentEventsResponseSchema,
@@ -17258,63 +17475,59 @@ var zeroRunAgentEventsContract = c24.router({
 });
 
 // ../../packages/core/src/contracts/zero-schedules.ts
-import { z as z31 } from "zod";
-var c25 = initContract();
-var scheduleResponseSchema = z31.object({
-  id: z31.string().uuid(),
-  agentId: z31.string().uuid(),
-  displayName: z31.string().nullable(),
-  orgSlug: z31.string(),
-  userId: z31.string(),
-  name: z31.string(),
-  triggerType: z31.enum(["cron", "once", "loop"]),
-  cronExpression: z31.string().nullable(),
-  atTime: z31.string().nullable(),
-  intervalSeconds: z31.number().nullable(),
-  timezone: z31.string(),
-  prompt: z31.string(),
-  description: z31.string().nullable(),
-  appendSystemPrompt: z31.string().nullable(),
-  vars: z31.record(z31.string(), z31.string()).nullable(),
-  secretNames: z31.array(z31.string()).nullable(),
-  artifactName: z31.string().nullable(),
-  artifactVersion: z31.string().nullable(),
-  volumeVersions: z31.record(z31.string(), z31.string()).nullable(),
-  enabled: z31.boolean(),
-  notifyEmail: z31.boolean(),
-  notifySlack: z31.boolean(),
-  slackChannelId: z31.string().nullable(),
-  nextRunAt: z31.string().nullable(),
-  lastRunAt: z31.string().nullable(),
-  retryStartedAt: z31.string().nullable(),
-  consecutiveFailures: z31.number(),
-  createdAt: z31.string(),
-  updatedAt: z31.string()
-});
-var scheduleListResponseSchema = z31.object({
-  schedules: z31.array(scheduleResponseSchema)
-});
-var deployScheduleResponseSchema = z31.object({
+import { z as z32 } from "zod";
+var c26 = initContract();
+var scheduleResponseSchema = z32.object({
+  id: z32.string().uuid(),
+  agentId: z32.string().uuid(),
+  displayName: z32.string().nullable(),
+  orgSlug: z32.string(),
+  userId: z32.string(),
+  name: z32.string(),
+  triggerType: z32.enum(["cron", "once", "loop"]),
+  cronExpression: z32.string().nullable(),
+  atTime: z32.string().nullable(),
+  intervalSeconds: z32.number().nullable(),
+  timezone: z32.string(),
+  prompt: z32.string(),
+  description: z32.string().nullable(),
+  appendSystemPrompt: z32.string().nullable(),
+  vars: z32.record(z32.string(), z32.string()).nullable(),
+  secretNames: z32.array(z32.string()).nullable(),
+  volumeVersions: z32.record(z32.string(), z32.string()).nullable(),
+  enabled: z32.boolean(),
+  notifyEmail: z32.boolean(),
+  notifySlack: z32.boolean(),
+  notifySlackChannelId: z32.string().nullable(),
+  nextRunAt: z32.string().nullable(),
+  lastRunAt: z32.string().nullable(),
+  retryStartedAt: z32.string().nullable(),
+  consecutiveFailures: z32.number(),
+  createdAt: z32.string(),
+  updatedAt: z32.string()
+});
+var scheduleListResponseSchema = z32.object({
+  schedules: z32.array(scheduleResponseSchema)
+});
+var deployScheduleResponseSchema = z32.object({
   schedule: scheduleResponseSchema,
-  created: z31.boolean()
-});
-var zeroDeployScheduleRequestSchema = z31.object({
-  name: z31.string().min(1).max(64, "Schedule name max 64 chars"),
-  cronExpression: z31.string().optional(),
-  atTime: z31.string().optional(),
-  intervalSeconds: z31.number().int().min(0).optional(),
-  timezone: z31.string().default("UTC"),
-  prompt: z31.string().min(1, "Prompt required"),
-  description: z31.string().optional(),
-  appendSystemPrompt: z31.string().optional(),
-  artifactName: z31.string().optional(),
-  artifactVersion: z31.string().optional(),
-  volumeVersions: z31.record(z31.string(), z31.string()).optional(),
-  agentId: z31.string().uuid("Invalid agent ID"),
-  enabled: z31.boolean().optional(),
-  notifyEmail: z31.boolean().optional(),
-  notifySlack: z31.boolean().optional(),
-  slackChannelId: z31.string().nullable().optional()
+  created: z32.boolean()
+});
+var zeroDeployScheduleRequestSchema = z32.object({
+  name: z32.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z32.string().optional(),
+  atTime: z32.string().optional(),
+  intervalSeconds: z32.number().int().min(0).optional(),
+  timezone: z32.string().default("UTC"),
+  prompt: z32.string().min(1, "Prompt required"),
+  description: z32.string().optional(),
+  appendSystemPrompt: z32.string().optional(),
+  volumeVersions: z32.record(z32.string(), z32.string()).optional(),
+  agentId: z32.string().uuid("Invalid agent ID"),
+  enabled: z32.boolean().optional(),
+  notifyEmail: z32.boolean().optional(),
+  notifySlack: z32.boolean().optional(),
+  notifySlackChannelId: z32.string().nullable().optional()
 }).refine(
   (data) => {
     const triggers = [
@@ -17328,7 +17541,7 @@ var zeroDeployScheduleRequestSchema = z31.object({
     message: "Exactly one of 'cronExpression', 'atTime', or 'intervalSeconds' must be specified"
   }
 );
-var zeroSchedulesMainContract = c25.router({
+var zeroSchedulesMainContract = c26.router({
   deploy: {
     method: "POST",
     path: "/api/zero/schedules",
@@ -17356,19 +17569,19 @@ var zeroSchedulesMainContract = c25.router({
     summary: "List all schedules (zero proxy)"
   }
 });
-var zeroSchedulesByNameContract = c25.router({
+var zeroSchedulesByNameContract = c26.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/schedules/:name",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      name: z31.string().min(1, "Schedule name required")
+    pathParams: z32.object({
+      name: z32.string().min(1, "Schedule name required")
     }),
-    query: z31.object({
-      agentId: z31.string().uuid("Invalid agent ID")
+    query: z32.object({
+      agentId: z32.string().uuid("Invalid agent ID")
     }),
     responses: {
-      204: c25.noBody(),
+      204: c26.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -17376,16 +17589,16 @@ var zeroSchedulesByNameContract = c25.router({
     summary: "Delete schedule (zero proxy)"
   }
 });
-var zeroSchedulesEnableContract = c25.router({
+var zeroSchedulesEnableContract = c26.router({
   enable: {
     method: "POST",
     path: "/api/zero/schedules/:name/enable",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      name: z31.string().min(1, "Schedule name required")
+    pathParams: z32.object({
+      name: z32.string().min(1, "Schedule name required")
     }),
-    body: z31.object({
-      agentId: z31.string().uuid("Invalid agent ID")
+    body: z32.object({
+      agentId: z32.string().uuid("Invalid agent ID")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -17400,11 +17613,11 @@ var zeroSchedulesEnableContract = c25.router({
     method: "POST",
     path: "/api/zero/schedules/:name/disable",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      name: z31.string().min(1, "Schedule name required")
+    pathParams: z32.object({
+      name: z32.string().min(1, "Schedule name required")
     }),
-    body: z31.object({
-      agentId: z31.string().uuid("Invalid agent ID")
+    body: z32.object({
+      agentId: z32.string().uuid("Invalid agent ID")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -17416,16 +17629,16 @@ var zeroSchedulesEnableContract = c25.router({
     summary: "Disable schedule (zero proxy)"
   }
 });
-var zeroScheduleRunContract = c25.router({
+var zeroScheduleRunContract = c26.router({
   run: {
     method: "POST",
     path: "/api/zero/schedules/run",
     headers: authHeadersSchema,
-    body: z31.object({
-      scheduleId: z31.string().uuid("Invalid schedule ID")
+    body: z32.object({
+      scheduleId: z32.string().uuid("Invalid schedule ID")
     }),
     responses: {
-      201: z31.object({ runId: z31.string() }),
+      201: z32.object({ runId: z32.string() }),
       400: apiErrorSchema,
       401: apiErrorSchema,
       404: apiErrorSchema,
@@ -17436,9 +17649,9 @@ var zeroScheduleRunContract = c25.router({
 });
 
 // ../../packages/core/src/contracts/zero-model-providers.ts
-import { z as z32 } from "zod";
-var c26 = initContract();
-var zeroModelProvidersMainContract = c26.router({
+import { z as z33 } from "zod";
+var c27 = initContract();
+var zeroModelProvidersMainContract = c27.router({
   list: {
     method: "GET",
     path: "/api/zero/model-providers",
@@ -17466,16 +17679,16 @@ var zeroModelProvidersMainContract = c26.router({
     summary: "Create or update an org-level model provider (admin only)"
   }
 });
-var zeroModelProvidersByTypeContract = c26.router({
+var zeroModelProvidersByTypeContract = c27.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/model-providers/:type",
     headers: authHeadersSchema,
-    pathParams: z32.object({
+    pathParams: z33.object({
       type: modelProviderTypeSchema
     }),
     responses: {
-      204: c26.noBody(),
+      204: c27.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema,
@@ -17484,15 +17697,15 @@ var zeroModelProvidersByTypeContract = c26.router({
     summary: "Delete an org-level model provider (admin only)"
   }
 });
-var zeroModelProvidersDefaultContract = c26.router({
+var zeroModelProvidersDefaultContract = c27.router({
   setDefault: {
     method: "POST",
     path: "/api/zero/model-providers/:type/default",
     headers: authHeadersSchema,
-    pathParams: z32.object({
+    pathParams: z33.object({
       type: modelProviderTypeSchema
     }),
-    body: z32.undefined(),
+    body: z33.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       401: apiErrorSchema,
@@ -17503,12 +17716,12 @@ var zeroModelProvidersDefaultContract = c26.router({
     summary: "Set org-level model provider as default (admin only)"
   }
 });
-var zeroModelProvidersUpdateModelContract = c26.router({
+var zeroModelProvidersUpdateModelContract = c27.router({
   updateModel: {
     method: "PATCH",
     path: "/api/zero/model-providers/:type/model",
     headers: authHeadersSchema,
-    pathParams: z32.object({
+    pathParams: z33.object({
       type: modelProviderTypeSchema
     }),
     body: updateModelRequestSchema,
@@ -17524,9 +17737,9 @@ var zeroModelProvidersUpdateModelContract = c26.router({
 });
 
 // ../../packages/core/src/contracts/zero-secrets.ts
-import { z as z33 } from "zod";
-var c27 = initContract();
-var zeroSecretsContract = c27.router({
+import { z as z34 } from "zod";
+var c28 = initContract();
+var zeroSecretsContract = c28.router({
   list: {
     method: "GET",
     path: "/api/zero/secrets",
@@ -17553,16 +17766,16 @@ var zeroSecretsContract = c27.router({
     summary: "Create or update a secret"
   }
 });
-var zeroSecretsByNameContract = c27.router({
+var zeroSecretsByNameContract = c28.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/secrets/:name",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z34.object({
       name: secretNameSchema
     }),
     responses: {
-      204: c27.noBody(),
+      204: c28.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -17570,7 +17783,7 @@ var zeroSecretsByNameContract = c27.router({
     summary: "Delete a secret by name"
   }
 });
-var zeroVariablesContract = c27.router({
+var zeroVariablesContract = c28.router({
   list: {
     method: "GET",
     path: "/api/zero/variables",
@@ -17597,16 +17810,16 @@ var zeroVariablesContract = c27.router({
     summary: "Create or update a variable"
   }
 });
-var zeroVariablesByNameContract = c27.router({
+var zeroVariablesByNameContract = c28.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/variables/:name",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z34.object({
       name: variableNameSchema
     }),
     responses: {
-      204: c27.noBody(),
+      204: c28.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -17616,25 +17829,25 @@ var zeroVariablesByNameContract = c27.router({
 });
 
 // ../../packages/core/src/contracts/zero-sessions.ts
-import { z as z34 } from "zod";
-var c28 = initContract();
-var zeroSessionResponseSchema = z34.object({
-  id: z34.string(),
-  agentId: z34.string(),
-  conversationId: z34.string().nullable(),
-  artifactName: z34.string().nullable(),
-  secretNames: z34.array(z34.string()).nullable(),
-  chatMessages: z34.array(storedChatMessageSchema2).optional(),
-  createdAt: z34.string(),
-  updatedAt: z34.string()
-});
-var zeroSessionsByIdContract = c28.router({
+import { z as z35 } from "zod";
+var c29 = initContract();
+var zeroSessionResponseSchema = z35.object({
+  id: z35.string(),
+  agentId: z35.string(),
+  conversationId: z35.string().nullable(),
+  artifactName: z35.string().nullable(),
+  secretNames: z35.array(z35.string()).nullable(),
+  chatMessages: z35.array(storedChatMessageSchema2).optional(),
+  createdAt: z35.string(),
+  updatedAt: z35.string()
+});
+var zeroSessionsByIdContract = c29.router({
   getById: {
     method: "GET",
     path: "/api/zero/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z34.object({
-      id: z34.string().min(1, "Session ID is required")
+    pathParams: z35.object({
+      id: z35.string().min(1, "Session ID is required")
     }),
     responses: {
       200: zeroSessionResponseSchema,
@@ -17647,20 +17860,20 @@ var zeroSessionsByIdContract = c28.router({
 });
 
 // ../../packages/core/src/contracts/integrations.ts
-import { z as z35 } from "zod";
-var c29 = initContract();
-var sendSlackMessageBodySchema = z35.object({
-  channel: z35.string().min(1, "Channel ID is required"),
-  text: z35.string().optional(),
-  threadTs: z35.string().optional(),
-  blocks: z35.array(z35.object({ type: z35.string() }).passthrough()).optional()
-});
-var sendSlackMessageResponseSchema = z35.object({
-  ok: z35.literal(true),
-  ts: z35.string().optional(),
-  channel: z35.string().optional()
-});
-var integrationsSlackMessageContract = c29.router({
+import { z as z36 } from "zod";
+var c30 = initContract();
+var sendSlackMessageBodySchema = z36.object({
+  channel: z36.string().min(1, "Channel ID is required"),
+  text: z36.string().optional(),
+  threadTs: z36.string().optional(),
+  blocks: z36.array(z36.object({ type: z36.string() }).passthrough()).optional()
+});
+var sendSlackMessageResponseSchema = z36.object({
+  ok: z36.literal(true),
+  ts: z36.string().optional(),
+  channel: z36.string().optional()
+});
+var integrationsSlackMessageContract = c30.router({
   sendMessage: {
     method: "POST",
     path: "/api/zero/integrations/slack/message",
@@ -17678,47 +17891,47 @@ var integrationsSlackMessageContract = c29.router({
 });
 
 // ../../packages/core/src/contracts/zero-billing.ts
-import { z as z36 } from "zod";
-var c30 = initContract();
-var autoRechargeSchema = z36.object({
-  enabled: z36.boolean(),
-  threshold: z36.number().nullable(),
-  amount: z36.number().nullable()
-});
-var creditExpirySchema = z36.object({
-  expiringNextCycle: z36.number(),
-  nextExpiryDate: z36.string().nullable()
-});
-var billingStatusResponseSchema = z36.object({
-  tier: z36.string(),
-  credits: z36.number(),
-  subscriptionStatus: z36.string().nullable(),
-  currentPeriodEnd: z36.string().nullable(),
-  cancelAtPeriodEnd: z36.boolean(),
-  hasSubscription: z36.boolean(),
+import { z as z37 } from "zod";
+var c31 = initContract();
+var autoRechargeSchema = z37.object({
+  enabled: z37.boolean(),
+  threshold: z37.number().nullable(),
+  amount: z37.number().nullable()
+});
+var creditExpirySchema = z37.object({
+  expiringNextCycle: z37.number(),
+  nextExpiryDate: z37.string().nullable()
+});
+var billingStatusResponseSchema = z37.object({
+  tier: z37.string(),
+  credits: z37.number(),
+  subscriptionStatus: z37.string().nullable(),
+  currentPeriodEnd: z37.string().nullable(),
+  cancelAtPeriodEnd: z37.boolean(),
+  hasSubscription: z37.boolean(),
   autoRecharge: autoRechargeSchema,
   creditExpiry: creditExpirySchema
 });
-var checkoutResponseSchema = z36.object({
-  url: z36.string()
+var checkoutResponseSchema = z37.object({
+  url: z37.string()
 });
-var portalResponseSchema = z36.object({
-  url: z36.string()
+var portalResponseSchema = z37.object({
+  url: z37.string()
 });
-var checkoutRequestSchema = z36.object({
-  tier: z36.enum(["pro", "team"]),
-  successUrl: z36.string().url(),
-  cancelUrl: z36.string().url()
+var checkoutRequestSchema = z37.object({
+  tier: z37.enum(["pro", "team"]),
+  successUrl: z37.string().url(),
+  cancelUrl: z37.string().url()
 });
-var portalRequestSchema = z36.object({
-  returnUrl: z36.string().min(1)
+var portalRequestSchema = z37.object({
+  returnUrl: z37.string().min(1)
 });
-var autoRechargeUpdateRequestSchema = z36.object({
-  enabled: z36.boolean(),
-  threshold: z36.number().int().positive().optional(),
-  amount: z36.number().int().min(1e3).optional()
+var autoRechargeUpdateRequestSchema = z37.object({
+  enabled: z37.boolean(),
+  threshold: z37.number().int().positive().optional(),
+  amount: z37.number().int().min(1e3).optional()
 });
-var zeroBillingStatusContract = c30.router({
+var zeroBillingStatusContract = c31.router({
   get: {
     method: "GET",
     path: "/api/zero/billing/status",
@@ -17731,7 +17944,7 @@ var zeroBillingStatusContract = c30.router({
     summary: "Get billing status for current org"
   }
 });
-var zeroBillingCheckoutContract = c30.router({
+var zeroBillingCheckoutContract = c31.router({
   create: {
     method: "POST",
     path: "/api/zero/billing/checkout",
@@ -17747,7 +17960,7 @@ var zeroBillingCheckoutContract = c30.router({
     summary: "Create Stripe checkout session"
   }
 });
-var zeroBillingPortalContract = c30.router({
+var zeroBillingPortalContract = c31.router({
   create: {
     method: "POST",
     path: "/api/zero/billing/portal",
@@ -17763,7 +17976,7 @@ var zeroBillingPortalContract = c30.router({
     summary: "Create Stripe billing portal session"
   }
 });
-var zeroBillingAutoRechargeContract = c30.router({
+var zeroBillingAutoRechargeContract = c31.router({
   get: {
     method: "GET",
     path: "/api/zero/billing/auto-recharge",
@@ -17790,18 +18003,18 @@ var zeroBillingAutoRechargeContract = c30.router({
     summary: "Update auto-recharge configuration"
   }
 });
-var invoiceSchema = z36.object({
-  id: z36.string(),
-  number: z36.string().nullable(),
-  date: z36.number(),
-  amount: z36.number(),
-  status: z36.string().nullable(),
-  hostedInvoiceUrl: z36.string().nullable()
+var invoiceSchema = z37.object({
+  id: z37.string(),
+  number: z37.string().nullable(),
+  date: z37.number(),
+  amount: z37.number(),
+  status: z37.string().nullable(),
+  hostedInvoiceUrl: z37.string().nullable()
 });
-var billingInvoicesResponseSchema = z36.object({
-  invoices: z36.array(invoiceSchema)
+var billingInvoicesResponseSchema = z37.object({
+  invoices: z37.array(invoiceSchema)
 });
-var zeroBillingInvoicesContract = c30.router({
+var zeroBillingInvoicesContract = c31.router({
   get: {
     method: "GET",
     path: "/api/zero/billing/invoices",
@@ -17814,14 +18027,14 @@ var zeroBillingInvoicesContract = c30.router({
     summary: "Get invoices for current org"
   }
 });
-var downgradeRequestSchema = z36.object({
-  targetTier: z36.enum(["free", "pro"])
+var downgradeRequestSchema = z37.object({
+  targetTier: z37.enum(["free", "pro"])
 });
-var downgradeResponseSchema = z36.object({
-  success: z36.boolean(),
-  effectiveDate: z36.string().nullable()
+var downgradeResponseSchema = z37.object({
+  success: z37.boolean(),
+  effectiveDate: z37.string().nullable()
 });
-var zeroBillingDowngradeContract = c30.router({
+var zeroBillingDowngradeContract = c31.router({
   create: {
     method: "POST",
     path: "/api/zero/billing/downgrade",
@@ -17840,26 +18053,26 @@ var zeroBillingDowngradeContract = c30.router({
 });
 
 // ../../packages/core/src/contracts/zero-usage.ts
-import { z as z37 } from "zod";
-var c31 = initContract();
-var memberUsageSchema = z37.object({
-  userId: z37.string(),
-  email: z37.string(),
-  inputTokens: z37.number(),
-  outputTokens: z37.number(),
-  cacheReadInputTokens: z37.number(),
-  cacheCreationInputTokens: z37.number(),
-  creditsCharged: z37.number(),
-  creditCap: z37.number().nullable()
-});
-var usageMembersResponseSchema = z37.object({
-  period: z37.object({
-    start: z37.string(),
-    end: z37.string()
+import { z as z38 } from "zod";
+var c32 = initContract();
+var memberUsageSchema = z38.object({
+  userId: z38.string(),
+  email: z38.string(),
+  inputTokens: z38.number(),
+  outputTokens: z38.number(),
+  cacheReadInputTokens: z38.number(),
+  cacheCreationInputTokens: z38.number(),
+  creditsCharged: z38.number(),
+  creditCap: z38.number().nullable()
+});
+var usageMembersResponseSchema = z38.object({
+  period: z38.object({
+    start: z38.string(),
+    end: z38.string()
   }).nullable(),
-  members: z37.array(memberUsageSchema)
+  members: z38.array(memberUsageSchema)
 });
-var zeroUsageMembersContract = c31.router({
+var zeroUsageMembersContract = c32.router({
   get: {
     method: "GET",
     path: "/api/zero/usage/members",
@@ -17874,24 +18087,24 @@ var zeroUsageMembersContract = c31.router({
 });
 
 // ../../packages/core/src/contracts/zero-team.ts
-import { z as z38 } from "zod";
-var c32 = initContract();
-var teamComposeItemSchema = z38.object({
-  id: z38.string(),
-  displayName: z38.string().nullable(),
-  description: z38.string().nullable(),
-  sound: z38.string().nullable(),
-  avatarUrl: z38.string().nullable(),
-  headVersionId: z38.string().nullable(),
-  updatedAt: z38.string()
-});
-var zeroTeamContract = c32.router({
+import { z as z39 } from "zod";
+var c33 = initContract();
+var teamComposeItemSchema = z39.object({
+  id: z39.string(),
+  displayName: z39.string().nullable(),
+  description: z39.string().nullable(),
+  sound: z39.string().nullable(),
+  avatarUrl: z39.string().nullable(),
+  headVersionId: z39.string().nullable(),
+  updatedAt: z39.string()
+});
+var zeroTeamContract = c33.router({
   list: {
     method: "GET",
     path: "/api/zero/team",
     headers: authHeadersSchema,
     responses: {
-      200: z38.array(teamComposeItemSchema),
+      200: z39.array(teamComposeItemSchema),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -17901,30 +18114,30 @@ var zeroTeamContract = c32.router({
 });
 
 // ../../packages/core/src/contracts/zero-integrations-slack.ts
-import { z as z39 } from "zod";
-var c33 = initContract();
-var slackEnvironmentSchema = z39.object({
-  requiredSecrets: z39.array(z39.string()),
-  requiredVars: z39.array(z39.string()),
-  missingSecrets: z39.array(z39.string()),
-  missingVars: z39.array(z39.string())
-});
-var slackOrgStatusSchema = z39.object({
-  isConnected: z39.boolean(),
-  isInstalled: z39.boolean().optional(),
-  workspaceName: z39.string().nullable().optional(),
-  isAdmin: z39.boolean(),
-  installUrl: z39.string().nullable().optional(),
-  connectUrl: z39.string().nullable().optional(),
-  defaultAgentName: z39.string().nullable().optional(),
-  agentOrgSlug: z39.string().nullable().optional(),
+import { z as z40 } from "zod";
+var c34 = initContract();
+var slackEnvironmentSchema = z40.object({
+  requiredSecrets: z40.array(z40.string()),
+  requiredVars: z40.array(z40.string()),
+  missingSecrets: z40.array(z40.string()),
+  missingVars: z40.array(z40.string())
+});
+var slackOrgStatusSchema = z40.object({
+  isConnected: z40.boolean(),
+  isInstalled: z40.boolean().optional(),
+  workspaceName: z40.string().nullable().optional(),
+  isAdmin: z40.boolean(),
+  installUrl: z40.string().nullable().optional(),
+  connectUrl: z40.string().nullable().optional(),
+  defaultAgentName: z40.string().nullable().optional(),
+  agentOrgSlug: z40.string().nullable().optional(),
   environment: slackEnvironmentSchema.optional(),
   /** True when the installation's granted scopes are outdated (admin-only). */
-  scopeMismatch: z39.boolean().optional(),
+  scopeMismatch: z40.boolean().optional(),
   /** OAuth install URL for re-authorization (admin-only, when scopeMismatch). */
-  reinstallUrl: z39.string().nullable().optional()
+  reinstallUrl: z40.string().nullable().optional()
 });
-var zeroIntegrationsSlackContract = c33.router({
+var zeroIntegrationsSlackContract = c34.router({
   getStatus: {
     method: "GET",
     path: "/api/zero/integrations/slack",
@@ -17939,12 +18152,12 @@ var zeroIntegrationsSlackContract = c33.router({
     method: "DELETE",
     path: "/api/zero/integrations/slack",
     headers: authHeadersSchema,
-    body: c33.noBody(),
-    query: z39.object({
-      action: z39.string().optional()
+    body: c34.noBody(),
+    query: z40.object({
+      action: z40.string().optional()
     }),
     responses: {
-      200: z39.object({ ok: z39.boolean() }),
+      200: z40.object({ ok: z40.boolean() }),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -17954,20 +18167,20 @@ var zeroIntegrationsSlackContract = c33.router({
 });
 
 // ../../packages/core/src/contracts/zero-slack-connect.ts
-import { z as z40 } from "zod";
-var c34 = initContract();
-var slackConnectStatusSchema = z40.object({
-  isConnected: z40.boolean(),
-  isAdmin: z40.boolean(),
-  workspaceName: z40.string().nullable().optional(),
-  defaultAgentName: z40.string().nullable().optional()
-});
-var slackConnectResponseSchema = z40.object({
-  success: z40.boolean(),
-  connectionId: z40.string(),
-  role: z40.string()
-});
-var zeroSlackConnectContract = c34.router({
+import { z as z41 } from "zod";
+var c35 = initContract();
+var slackConnectStatusSchema = z41.object({
+  isConnected: z41.boolean(),
+  isAdmin: z41.boolean(),
+  workspaceName: z41.string().nullable().optional(),
+  defaultAgentName: z41.string().nullable().optional()
+});
+var slackConnectResponseSchema = z41.object({
+  success: z41.boolean(),
+  connectionId: z41.string(),
+  role: z41.string()
+});
+var zeroSlackConnectContract = c35.router({
   getStatus: {
     method: "GET",
     path: "/api/zero/integrations/slack/connect",
@@ -17982,11 +18195,11 @@ var zeroSlackConnectContract = c34.router({
     method: "POST",
     path: "/api/zero/integrations/slack/connect",
     headers: authHeadersSchema,
-    body: z40.object({
-      workspaceId: z40.string().min(1),
-      slackUserId: z40.string().min(1),
-      channelId: z40.string().optional(),
-      threadTs: z40.string().optional()
+    body: z41.object({
+      workspaceId: z41.string().min(1),
+      slackUserId: z41.string().min(1),
+      channelId: z41.string().optional(),
+      threadTs: z41.string().optional()
     }),
     responses: {
       200: slackConnectResponseSchema,
@@ -18000,19 +18213,19 @@ var zeroSlackConnectContract = c34.router({
 });
 
 // ../../packages/core/src/contracts/zero-slack-channels.ts
-import { z as z41 } from "zod";
-var c35 = initContract();
-var slackChannelSchema = z41.object({
-  id: z41.string(),
-  name: z41.string()
+import { z as z42 } from "zod";
+var c36 = initContract();
+var slackChannelSchema = z42.object({
+  id: z42.string(),
+  name: z42.string()
 });
-var zeroSlackChannelsContract = c35.router({
+var zeroSlackChannelsContract = c36.router({
   list: {
     method: "GET",
     path: "/api/zero/slack/channels",
     headers: authHeadersSchema,
     responses: {
-      200: z41.object({ channels: z41.array(slackChannelSchema) }),
+      200: z42.object({ channels: z42.array(slackChannelSchema) }),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
@@ -18021,19 +18234,19 @@ var zeroSlackChannelsContract = c35.router({
 });
 
 // ../../packages/core/src/contracts/zero-queue-position.ts
-import { z as z42 } from "zod";
-var c36 = initContract();
-var queuePositionResponseSchema = z42.object({
-  position: z42.number(),
-  total: z42.number()
+import { z as z43 } from "zod";
+var c37 = initContract();
+var queuePositionResponseSchema = z43.object({
+  position: z43.number(),
+  total: z43.number()
 });
-var zeroQueuePositionContract = c36.router({
+var zeroQueuePositionContract = c37.router({
   getPosition: {
     method: "GET",
     path: "/api/zero/queue-position",
     headers: authHeadersSchema,
-    query: z42.object({
-      runId: z42.string().min(1, "runId is required")
+    query: z43.object({
+      runId: z43.string().min(1, "runId is required")
     }),
     responses: {
       200: queuePositionResponseSchema,
@@ -18046,20 +18259,20 @@ var zeroQueuePositionContract = c36.router({
 });
 
 // ../../packages/core/src/contracts/zero-member-credit-cap.ts
-import { z as z43 } from "zod";
-var c37 = initContract();
-var memberCreditCapResponseSchema = z43.object({
-  userId: z43.string(),
-  creditCap: z43.number().nullable(),
-  creditEnabled: z43.boolean()
+import { z as z44 } from "zod";
+var c38 = initContract();
+var memberCreditCapResponseSchema = z44.object({
+  userId: z44.string(),
+  creditCap: z44.number().nullable(),
+  creditEnabled: z44.boolean()
 });
-var zeroMemberCreditCapContract = c37.router({
+var zeroMemberCreditCapContract = c38.router({
   get: {
     method: "GET",
     path: "/api/zero/org/members/credit-cap",
     headers: authHeadersSchema,
-    query: z43.object({
-      userId: z43.string().min(1, "userId is required")
+    query: z44.object({
+      userId: z44.string().min(1, "userId is required")
     }),
     responses: {
       200: memberCreditCapResponseSchema,
@@ -18072,9 +18285,9 @@ var zeroMemberCreditCapContract = c37.router({
     method: "PUT",
     path: "/api/zero/org/members/credit-cap",
     headers: authHeadersSchema,
-    body: z43.object({
-      userId: z43.string().min(1),
-      creditCap: z43.number().int().positive().nullable()
+    body: z44.object({
+      userId: z44.string().min(1),
+      creditCap: z44.number().int().positive().nullable()
     }),
     responses: {
       200: memberCreditCapResponseSchema,
@@ -18087,35 +18300,35 @@ var zeroMemberCreditCapContract = c37.router({
 });
 
 // ../../packages/core/src/contracts/zero-ask-user.ts
-import { z as z44 } from "zod";
-var c38 = initContract();
-var askUserQuestionItemSchema = z44.object({
-  question: z44.string().min(1),
-  header: z44.string().max(12).optional(),
-  options: z44.array(
-    z44.object({
-      label: z44.string(),
-      description: z44.string().optional()
+import { z as z45 } from "zod";
+var c39 = initContract();
+var askUserQuestionItemSchema = z45.object({
+  question: z45.string().min(1),
+  header: z45.string().max(12).optional(),
+  options: z45.array(
+    z45.object({
+      label: z45.string(),
+      description: z45.string().optional()
     })
   ).min(1),
-  multiSelect: z44.boolean().optional()
+  multiSelect: z45.boolean().optional()
 });
-var askUserQuestionBodySchema = z44.object({
-  questions: z44.array(askUserQuestionItemSchema).min(1)
+var askUserQuestionBodySchema = z45.object({
+  questions: z45.array(askUserQuestionItemSchema).min(1)
 });
-var askUserQuestionResponseSchema = z44.object({
-  pendingId: z44.string().uuid()
+var askUserQuestionResponseSchema = z45.object({
+  pendingId: z45.string().uuid()
 });
-var askUserAnswerStatusSchema = z44.enum([
+var askUserAnswerStatusSchema = z45.enum([
   "pending",
   "answered",
   "expired"
 ]);
-var askUserAnswerResponseSchema = z44.object({
+var askUserAnswerResponseSchema = z45.object({
   status: askUserAnswerStatusSchema,
-  answer: z44.string().optional()
+  answer: z45.string().optional()
 });
-var zeroAskUserQuestionContract = c38.router({
+var zeroAskUserQuestionContract = c39.router({
   postQuestion: {
     method: "POST",
     path: "/api/zero/ask-user/question",
@@ -18129,13 +18342,13 @@ var zeroAskUserQuestionContract = c38.router({
     summary: "Submit a question for the user and receive a pending ID for polling"
   }
 });
-var zeroAskUserAnswerContract = c38.router({
+var zeroAskUserAnswerContract = c39.router({
   getAnswer: {
     method: "GET",
     path: "/api/zero/ask-user/answer",
     headers: authHeadersSchema,
-    query: z44.object({
-      pendingId: z44.string().uuid()
+    query: z45.object({
+      pendingId: z45.string().uuid()
     }),
     responses: {
       200: askUserAnswerResponseSchema,
@@ -19282,6 +19495,29 @@ async function getZeroAgentInstructions(id) {
   if (result.status === 200) return result.body;
   handleError(result, `Failed to get instructions for zero agent "${id}"`);
 }
+async function getZeroAgentUserConnectors(id) {
+  const config = await getClientConfig();
+  const client = initClient15(zeroUserConnectorsContract, config);
+  const result = await client.get({ params: { id } });
+  if (result.status === 200) return result.body.enabledTypes;
+  handleError(
+    result,
+    `Failed to get connector permissions for zero agent "${id}"`
+  );
+}
+async function setZeroAgentUserConnectors(id, enabledTypes) {
+  const config = await getClientConfig();
+  const client = initClient15(zeroUserConnectorsContract, config);
+  const result = await client.update({
+    params: { id },
+    body: { enabledTypes }
+  });
+  if (result.status === 200) return;
+  handleError(
+    result,
+    `Failed to set connector permissions for zero agent "${id}"`
+  );
+}
 async function updateZeroAgentInstructions(id, content) {
   const config = await getClientConfig();
   const client = initClient15(zeroAgentInstructionsContract, config);
@@ -20381,6 +20617,8 @@ export {
   updateZeroAgent,
   deleteZeroAgent,
   getZeroAgentInstructions,
+  getZeroAgentUserConnectors,
+  setZeroAgentUserConnectors,
   updateZeroAgentInstructions,
   listZeroConnectors,
   getZeroConnector,
@@ -20426,4 +20664,4 @@ export {
   pollEvents,
   showNextSteps
 };
-//# sourceMappingURL=chunk-JOVCRTRX.js.map
+//# sourceMappingURL=chunk-NM4FYPVK.js.map