@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/src/atlassian-native-retirement.ts

@@ -0,0 +1,33 @@
+/** The former API/Knowledge-sync adapter is historical; hosted Atlassian MCP remains supported. */
+export const ATLASSIAN_NATIVE_RETIRED_REASON = "atlassian_native_retired" as const;
+export const ATLASSIAN_NATIVE_RETIRED_MESSAGE =
+  "Jira and Confluence knowledge sync has been retired. Connect Atlassian agent tools to use its hosted MCP server.";
+export const RETIRED_NATIVE_ATLASSIAN_TOOL_NAMES = [
+  "atlassian_sources_list",
+  "atlassian_search",
+  "atlassian_get",
+] as const;
+
+export function isRetiredNativeAtlassianTool(name: string): boolean {
+  return (RETIRED_NATIVE_ATLASSIAN_TOOL_NAMES as readonly string[]).includes(name);
+}
+
+/** Match the native source identity, never the hosted MCP provider or a display name. */
+export function isRetiredNativeAtlassianSource(source: unknown): boolean {
+  if (!source || typeof source !== "object") return false;
+  const connection = (source as { connection?: unknown }).connection;
+  if (!connection || typeof connection !== "object") return false;
+  const provider = (connection as { providerDomain?: unknown }).providerDomain;
+  return typeof provider === "string" && provider.toLowerCase() === "api.atlassian.com";
+}
+
+/** Includes frozen historical source actions without changing their stored bytes. */
+export function isRetiredNativeAtlassianTask(task: {
+  agentConfig?: { knowledgeSource?: unknown } | null;
+  action?: { kind?: unknown } | null;
+}): boolean {
+  return (
+    isRetiredNativeAtlassianSource(task.agentConfig?.knowledgeSource) ||
+    (task.action?.kind === "knowledge_source_sync" && isRetiredNativeAtlassianSource(task.action))
+  );
+}

package/src/atlassian.ts

@@ -1,3 +1,5 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 import { ConnectionMetadata } from "./index";
 import { ConnectorDocumentDestination } from "./connector-destinations";
@@ -19,139 +21,165 @@ export const ATLASSIAN_REQUIRED_SCOPES = [
   "read:comment:confluence",
 ] as const;
 
-export const AtlassianSourceKind = z.enum(["jira_project", "confluence_space"]);
+export const AtlassianSourceKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["jira_project", "confluence_space"]),
+);
 export type AtlassianSourceKind = z.infer<typeof AtlassianSourceKind>;
 
-export const AtlassianSyncCadence = z.enum(["manual", "hourly", "daily"]);
+export const AtlassianSyncCadence = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["manual", "hourly", "daily"]),
+);
 export type AtlassianSyncCadence = z.infer<typeof AtlassianSyncCadence>;
 
-export const AtlassianReadPolicy = z.enum(["allow", "ask", "block"]);
+export const AtlassianReadPolicy = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["allow", "ask", "block"]),
+);
 export type AtlassianReadPolicy = z.infer<typeof AtlassianReadPolicy>;
 
-export const AtlassianConnectionLifecycle = z.object({
-  state: z.enum([
-    "active",
-    "paused",
-    "token_revoked",
-    "app_removed",
-    "disconnected",
-    "reconnect_required",
-    "reconsent_required",
-  ]),
-  recoverable: z.boolean(),
-  observedAt: z.string().datetime(),
-});
+export const AtlassianConnectionLifecycle = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    state: z.enum([
+      "active",
+      "paused",
+      "token_revoked",
+      "app_removed",
+      "disconnected",
+      "reconnect_required",
+      "reconsent_required",
+    ]),
+    recoverable: primitives.boolean,
+    observedAt: primitives.dateTime,
+  }),
+);
 export type AtlassianConnectionLifecycle = z.infer<typeof AtlassianConnectionLifecycle>;
 
-export const AtlassianSelectedSource = z.object({
-  id: z.string().min(1).max(300),
-  cloudId: z.string().min(1).max(256),
-  siteName: z.string().min(1).max(512),
-  siteUrl: z.string().url(),
-  resourceId: z.string().min(1).max(256),
-  key: z.string().min(1).max(128),
-  name: z.string().min(1).max(512),
-  kind: AtlassianSourceKind,
-  destination: ConnectorDocumentDestination.optional(),
-  syncCadence: AtlassianSyncCadence,
-  syncEnabled: z.boolean(),
-  configGeneration: z.number().int().positive(),
-  readPolicy: AtlassianReadPolicy,
-  selectedAt: z.string().datetime(),
-});
+export const AtlassianSelectedSource = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().min(1).max(300),
+    cloudId: z.string().min(1).max(256),
+    siteName: z.string().min(1).max(512),
+    siteUrl: z.string().url(),
+    resourceId: z.string().min(1).max(256),
+    key: z.string().min(1).max(128),
+    name: z.string().min(1).max(512),
+    kind: AtlassianSourceKind,
+    destination: ConnectorDocumentDestination.optional(),
+    syncCadence: AtlassianSyncCadence,
+    syncEnabled: primitives.boolean,
+    configGeneration: primitives.positiveInteger,
+    readPolicy: AtlassianReadPolicy,
+    selectedAt: primitives.dateTime,
+  }),
+);
 export type AtlassianSelectedSource = z.infer<typeof AtlassianSelectedSource>;
 
-export const AtlassianConnectionMetadata = z.object({
-  credentialRole: z.literal(ATLASSIAN_CREDENTIAL_ROLE),
-  credentialLabel: z.literal(ATLASSIAN_CREDENTIAL_LABEL),
-  atlassianAccountId: z.string().min(1).max(256),
-  displayName: z.string().min(1).max(512),
-  email: z.string().email().nullable().optional(),
-  sites: z
-    .array(
-      z.object({
-        cloudId: z.string().min(1).max(256),
-        name: z.string().min(1).max(512),
-        url: z.string().url(),
-        products: z.array(z.enum(["jira", "confluence"])).max(2),
-      }),
-    )
-    .min(1)
-    .max(50),
-  verifiedAt: z.string().datetime(),
-  accessMode: z.literal("readonly"),
-  lifecycle: AtlassianConnectionLifecycle.optional(),
-  documentDestination: ConnectorDocumentDestination.optional(),
-  selectedSources: z.array(AtlassianSelectedSource).max(100).default([]),
-});
+export const AtlassianConnectionMetadata = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    credentialRole: z.literal(ATLASSIAN_CREDENTIAL_ROLE),
+    credentialLabel: z.literal(ATLASSIAN_CREDENTIAL_LABEL),
+    atlassianAccountId: z.string().min(1).max(256),
+    displayName: z.string().min(1).max(512),
+    email: z.string().email().nullable().optional(),
+    sites: z
+      .array(
+        z.object({
+          cloudId: z.string().min(1).max(256),
+          name: z.string().min(1).max(512),
+          url: z.string().url(),
+          products: z.array(z.enum(["jira", "confluence"])).max(2),
+        }),
+      )
+      .min(1)
+      .max(50),
+    verifiedAt: primitives.dateTime,
+    accessMode: z.literal("readonly"),
+    lifecycle: AtlassianConnectionLifecycle.optional(),
+    documentDestination: ConnectorDocumentDestination.optional(),
+    selectedSources: z.array(AtlassianSelectedSource).max(100).default([]),
+  }),
+);
 export type AtlassianConnectionMetadata = z.infer<typeof AtlassianConnectionMetadata>;
 
-export const AtlassianOAuthStartRequest = z.object({
-  connectionId: z.string().uuid().optional(),
-});
+export const AtlassianOAuthStartRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    connectionId: primitives.optionalUuid,
+  }),
+);
 export type AtlassianOAuthStartRequest = z.infer<typeof AtlassianOAuthStartRequest>;
 
-export const AtlassianOAuthStartResponse = z.object({
-  authorizationUrl: z.string().url(),
-  expiresAt: z.string().datetime(),
-});
+export const AtlassianOAuthStartResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    authorizationUrl: z.string().url(),
+    expiresAt: primitives.dateTime,
+  }),
+);
 export type AtlassianOAuthStartResponse = z.infer<typeof AtlassianOAuthStartResponse>;
 
-export const AtlassianBrowseItem = z.object({
-  id: z.string().min(1).max(300),
-  cloudId: z.string().min(1).max(256),
-  siteName: z.string().min(1).max(512),
-  siteUrl: z.string().url(),
-  resourceId: z.string().min(1).max(256),
-  key: z.string().min(1).max(128),
-  name: z.string().min(1).max(512),
-  kind: AtlassianSourceKind,
-  description: z.string().max(2_000).nullable(),
-  webUrl: z.string().url(),
-});
+export const AtlassianBrowseItem = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().min(1).max(300),
+    cloudId: z.string().min(1).max(256),
+    siteName: z.string().min(1).max(512),
+    siteUrl: z.string().url(),
+    resourceId: z.string().min(1).max(256),
+    key: z.string().min(1).max(128),
+    name: z.string().min(1).max(512),
+    kind: AtlassianSourceKind,
+    description: z.string().max(2_000).nullable(),
+    webUrl: z.string().url(),
+  }),
+);
 export type AtlassianBrowseItem = z.infer<typeof AtlassianBrowseItem>;
 
-export const AtlassianBrowseResponse = z.object({
-  connection: z.lazy(() => ConnectionMetadata),
-  items: z.array(AtlassianBrowseItem).max(200),
-});
+export const AtlassianBrowseResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    connection: z.lazy(() => ConnectionMetadata),
+    items: z.array(AtlassianBrowseItem).max(200),
+  }),
+);
 export type AtlassianBrowseResponse = z.infer<typeof AtlassianBrowseResponse>;
 
-export const SaveAtlassianSourcesRequest = z.object({
-  sources: z
-    .array(
-      AtlassianBrowseItem.pick({
-        id: true,
-        cloudId: true,
-        siteName: true,
-        siteUrl: true,
-        resourceId: true,
-        key: true,
-        name: true,
-        kind: true,
-      }),
-    )
-    .max(100),
-  destination: z.object({
-    authorityKind: z.enum(["organization", "workspace", "personal"]),
-    collectionId: z.string().uuid().nullable().default(null),
+export const SaveAtlassianSourcesRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    sources: z
+      .array(
+        AtlassianBrowseItem.pick({
+          id: true,
+          cloudId: true,
+          siteName: true,
+          siteUrl: true,
+          resourceId: true,
+          key: true,
+          name: true,
+          kind: true,
+        }),
+      )
+      .max(100),
+    destination: z.object({
+      authorityKind: z.enum(["organization", "workspace", "personal"]),
+      collectionId: primitives.nullableUuid.default(null),
+    }),
+    syncCadence: AtlassianSyncCadence,
+    syncEnabled: primitives.boolean,
+    readPolicy: AtlassianReadPolicy.default("allow"),
   }),
-  syncCadence: AtlassianSyncCadence,
-  syncEnabled: z.boolean(),
-  readPolicy: AtlassianReadPolicy.default("allow"),
-});
+);
 export type SaveAtlassianSourcesRequest = z.infer<typeof SaveAtlassianSourcesRequest>;
 
-export const AtlassianLifecycleActionRequest = z.object({
-  action: z.enum(["pause", "resume"]),
-  expectedVersion: z.number().int().positive(),
-});
+export const AtlassianLifecycleActionRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    action: z.enum(["pause", "resume"]),
+    expectedVersion: primitives.positiveInteger,
+  }),
+);
 export type AtlassianLifecycleActionRequest = z.infer<typeof AtlassianLifecycleActionRequest>;
 
-export const AtlassianDisconnectRequest = z.object({
-  expectedVersion: z.number().int().positive(),
-  idempotencyKey: z.string().uuid(),
-});
+export const AtlassianDisconnectRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    expectedVersion: primitives.positiveInteger,
+    idempotencyKey: primitives.uuid,
+  }),
+);
 export type AtlassianDisconnectRequest = z.infer<typeof AtlassianDisconnectRequest>;
 
 export function atlassianScopesAllowRead(scopes: readonly string[]): boolean {

package/src/automation-templates.ts

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import { defineSchema } from "./define-schema";
+import {
+  EVENT_TRIGGER_CONDITIONS_MAX,
+  EVENT_TRIGGER_TYPES_MAX,
+  EVENT_TRIGGERS_PER_AUTOMATION_MAX,
+  EventCondition,
+  EventSourceKind,
+  EventTypeName,
+  MAX_EVENT_RUNS_PER_HOUR,
+  WebhookEventAdapter,
+} from "./event-triggers";
+
+/**
+ * Automation templates: where a new automation starts. A template holds what
+ * an automation does and when, but never where its runs go, who owns it or
+ * which accounts it uses: those come from wherever it is used. Its schedule
+ * has no time zone (the person's own applies) and its triggers name a kind
+ * of source rather than a source, since sources differ per person.
+ *
+ * Built-in and host templates live in the client. A workspace keeps the
+ * templates its people save from their automations.
+ *
+ * This module must not import `./index`.
+ */
+
+export const AUTOMATION_TEMPLATE_NAME_MAX_LENGTH = 120;
+export const AUTOMATION_TEMPLATE_DESCRIPTION_MAX_LENGTH = 500;
+export const AUTOMATION_TEMPLATE_INSTRUCTIONS_MAX_LENGTH = 20_000;
+/** Saved templates a workspace keeps; saving another past this is refused. */
+export const AUTOMATION_TEMPLATES_PER_WORKSPACE_MAX = 200;
+
+const Uuid = /* @__PURE__ */ defineSchema(() => z.string().uuid());
+
+/** When it runs, read in the time zone of whoever uses the template. */
+export const AutomationTemplateSchedule = /* @__PURE__ */ defineSchema(() =>
+  z.discriminatedUnion("type", [
+    z
+      .object({
+        type: z.literal("calendar"),
+        hour: z.number().int().min(0).max(23),
+        minute: z.number().int().min(0).max(59),
+        /** Omitted: every day. */
+        daysOfWeek: z
+          .array(
+            z.enum(["SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY"]),
+          )
+          .min(1)
+          .max(7)
+          .optional(),
+      })
+      .strict(),
+    z
+      .object({
+        type: z.literal("interval"),
+        everySeconds: z
+          .number()
+          .int()
+          .min(60)
+          .max(366 * 86_400),
+      })
+      .strict(),
+  ]),
+);
+export type AutomationTemplateSchedule = z.infer<typeof AutomationTemplateSchedule>;
+
+/**
+ * The kind of source a template trigger listens on: GitHub, a Linear webhook,
+ * one MCP server, this workspace. `sourceId` names a source shared with the
+ * workspace, used when the person can use it; otherwise their own source of
+ * this kind is.
+ */
+export const AutomationTemplateEventSource = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      kind: EventSourceKind,
+      /** For a webhook: how it verifies and reads deliveries. */
+      adapter: WebhookEventAdapter.optional(),
+      /** For an MCP source: the server, as configured for the workspace. */
+      mcpServerId: z.string().min(1).max(256).optional(),
+      sourceId: Uuid.optional(),
+    })
+    .strict()
+    .superRefine((source, context) => {
+      if ((source.kind === "webhook") !== (source.adapter !== undefined)) {
+        context.addIssue({
+          code: "custom",
+          path: ["adapter"],
+          message: "A webhook source names its adapter, and only a webhook source does",
+        });
+      }
+      if ((source.kind === "mcp") !== (source.mcpServerId !== undefined)) {
+        context.addIssue({
+          code: "custom",
+          path: ["mcpServerId"],
+          message: "An MCP source names its server, and only an MCP source does",
+        });
+      }
+    }),
+);
+export type AutomationTemplateEventSource = z.infer<typeof AutomationTemplateEventSource>;
+
+export const AutomationTemplateTrigger = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      source: AutomationTemplateEventSource,
+      eventTypes: z.array(EventTypeName).min(1).max(EVENT_TRIGGER_TYPES_MAX),
+      conditions: z.array(EventCondition).max(EVENT_TRIGGER_CONDITIONS_MAX).default([]),
+      /** Also fire on events made by Opengeni's own bots. */
+      includeOwnEvents: z.boolean().default(false),
+      /** MCP subscription arguments. */
+      arguments: z.record(z.string(), z.unknown()).optional(),
+    })
+    .strict(),
+);
+export type AutomationTemplateTrigger = z.input<typeof AutomationTemplateTrigger>;
+
+const TemplateName = /* @__PURE__ */ defineSchema(() =>
+  z.string().trim().min(1).max(AUTOMATION_TEMPLATE_NAME_MAX_LENGTH),
+);
+const TemplateDescription = /* @__PURE__ */ defineSchema(() =>
+  z.string().trim().max(AUTOMATION_TEMPLATE_DESCRIPTION_MAX_LENGTH),
+);
+/** What the agent does on each run. */
+const TemplateInstructions = /* @__PURE__ */ defineSchema(() =>
+  z.string().trim().min(1).max(AUTOMATION_TEMPLATE_INSTRUCTIONS_MAX_LENGTH),
+);
+const TemplateTriggers = /* @__PURE__ */ defineSchema(() =>
+  z.array(AutomationTemplateTrigger).max(EVENT_TRIGGERS_PER_AUTOMATION_MAX),
+);
+/** The storm guard for event runs; null takes the default. */
+const TemplateMaxRunsPerHour = /* @__PURE__ */ defineSchema(() =>
+  z.number().int().min(1).max(MAX_EVENT_RUNS_PER_HOUR).nullable(),
+);
+
+/** A template saved in a workspace. */
+export const WorkspaceAutomationTemplate = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: Uuid,
+    workspaceId: Uuid,
+    name: z.string(),
+    description: z.string(),
+    instructions: z.string(),
+    /** Null: it runs only on its events or with Run now. */
+    schedule: AutomationTemplateSchedule.nullable(),
+    triggers: TemplateTriggers,
+    maxRunsPerHour: TemplateMaxRunsPerHour,
+    /** Who saved it; null when a workspace-level caller did. */
+    createdBySubjectId: z.string().nullable(),
+    /** `manage`: the reader may rename, change or delete it. */
+    viewerAccess: z.enum(["manage", "use"]),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+  }),
+);
+export type WorkspaceAutomationTemplate = z.output<typeof WorkspaceAutomationTemplate>;
+
+export const CreateAutomationTemplateRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      name: TemplateName,
+      description: TemplateDescription.default(""),
+      instructions: TemplateInstructions,
+      schedule: AutomationTemplateSchedule.nullable().default(null),
+      triggers: TemplateTriggers.default([]),
+      maxRunsPerHour: TemplateMaxRunsPerHour.default(null),
+    })
+    .strict(),
+);
+export type CreateAutomationTemplateRequest = z.input<typeof CreateAutomationTemplateRequest>;
+export type ParsedCreateAutomationTemplateRequest = z.output<
+  typeof CreateAutomationTemplateRequest
+>;
+
+/** Changes only what it names. */
+export const UpdateAutomationTemplateRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      name: TemplateName.optional(),
+      description: TemplateDescription.optional(),
+      instructions: TemplateInstructions.optional(),
+      schedule: AutomationTemplateSchedule.nullable().optional(),
+      triggers: TemplateTriggers.optional(),
+      maxRunsPerHour: TemplateMaxRunsPerHour.optional(),
+    })
+    .strict(),
+);
+export type UpdateAutomationTemplateRequest = z.input<typeof UpdateAutomationTemplateRequest>;
+export type ParsedUpdateAutomationTemplateRequest = z.output<
+  typeof UpdateAutomationTemplateRequest
+>;
+
+export const ListAutomationTemplatesResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({ templates: z.array(WorkspaceAutomationTemplate) }),
+);
+export type ListAutomationTemplatesResponse = z.output<typeof ListAutomationTemplatesResponse>;
+
+export const AutomationTemplateResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({ template: WorkspaceAutomationTemplate }),
+);
+export type AutomationTemplateResponse = z.output<typeof AutomationTemplateResponse>;

package/src/billing-subscriptions.ts

@@ -0,0 +1,48 @@
+import * as primitives from "./primitives";
+import { z } from "zod";
+import { BillingPlanBalance, SubscriptionPlan } from "./subscription-plans";
+
+export const BillingSubscriptionCatalog = z.object({
+  accountId: primitives.uuid,
+  revision: primitives.positiveInteger,
+  plans: z.array(SubscriptionPlan.extend({ selfService: primitives.boolean })),
+  plan: BillingPlanBalance.nullable(),
+});
+export type BillingSubscriptionCatalog = z.infer<typeof BillingSubscriptionCatalog>;
+
+export const CreateSubscriptionCheckoutRequest = z.strictObject({
+  accountId: primitives.optionalUuid,
+  planKey: z.string().min(1).max(40),
+  /** Stable across retries of the same action; use a fresh UUID for a new action. */
+  idempotencyKey: primitives.uuid,
+  successUrl: z.string().url().optional(),
+  cancelUrl: z.string().url().optional(),
+});
+export type CreateSubscriptionCheckoutRequest = z.infer<typeof CreateSubscriptionCheckoutRequest>;
+
+export const CreateSubscriptionCheckoutResponse = z.object({
+  checkoutSessionId: primitives.string,
+  url: z.string().url(),
+});
+export type CreateSubscriptionCheckoutResponse = z.infer<typeof CreateSubscriptionCheckoutResponse>;
+
+export const ChangeBillingSubscriptionRequest = z.strictObject({
+  accountId: primitives.optionalUuid,
+  planKey: z.string().min(1).max(40),
+  idempotencyKey: primitives.uuid,
+});
+export type ChangeBillingSubscriptionRequest = z.infer<typeof ChangeBillingSubscriptionRequest>;
+
+export const CancelBillingSubscriptionRequest = z.strictObject({
+  accountId: primitives.optionalUuid,
+  idempotencyKey: primitives.uuid,
+});
+export type CancelBillingSubscriptionRequest = z.infer<typeof CancelBillingSubscriptionRequest>;
+
+export const BillingSubscriptionChange = z.object({
+  subscriptionId: primitives.string,
+  planKey: primitives.string,
+  effectiveAt: primitives.dateTime,
+  cancelAtPeriodEnd: primitives.boolean,
+});
+export type BillingSubscriptionChange = z.infer<typeof BillingSubscriptionChange>;