@opengeni/contracts 0.44.1 → 0.50.0

package/src/knowledge.ts

@@ -0,0 +1,207 @@
+import { z } from "zod";
+
+export const KNOWLEDGE_BROWSE_CURSOR_MAX_CHARS = 1_024;
+export const KNOWLEDGE_BROWSE_DEFAULT_LIMIT = 20;
+export const KNOWLEDGE_BROWSE_MAX_LIMIT = 50;
+export const KNOWLEDGE_TITLE_MAX_BYTES = 1_024;
+export const KNOWLEDGE_BODY_MAX_BYTES = 16 * 1_024;
+export const KNOWLEDGE_SUMMARY_MAX_BYTES = 4 * 1_024;
+export const KNOWLEDGE_TOPIC_MAX_BYTES = 256;
+export const KNOWLEDGE_TOPICS_MAX_ITEMS = 32;
+export const KNOWLEDGE_METADATA_MAX_BYTES = 8 * 1_024;
+export const KNOWLEDGE_METADATA_MAX_ITEMS = 64;
+export const KNOWLEDGE_METADATA_MAX_DEPTH = 4;
+export const KNOWLEDGE_SOURCE_STRING_MAX_BYTES = 2_048;
+export const KNOWLEDGE_SOURCE_URI_MAX_BYTES = 8_192;
+
+const utf8Bytes = (value: string): number => new TextEncoder().encode(value).byteLength;
+const boundedUtf8 = (maxBytes: number) =>
+  z.string().superRefine((value, ctx) => {
+    if (utf8Bytes(value) > maxBytes) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `must be at most ${maxBytes} UTF-8 bytes`,
+      });
+    }
+  });
+
+function boundedJson(value: unknown): boolean {
+  let items = 0;
+  let valid = true;
+  const visit = (candidate: unknown, depth: number): void => {
+    if (!valid || ++items > KNOWLEDGE_METADATA_MAX_ITEMS || depth > KNOWLEDGE_METADATA_MAX_DEPTH) {
+      valid = false;
+      return;
+    }
+    if (
+      candidate === null ||
+      typeof candidate === "boolean" ||
+      (typeof candidate === "number" && Number.isFinite(candidate))
+    ) {
+      return;
+    }
+    if (typeof candidate === "string") {
+      if (utf8Bytes(candidate) > KNOWLEDGE_SOURCE_STRING_MAX_BYTES) valid = false;
+      return;
+    }
+    if (Array.isArray(candidate)) {
+      for (const item of candidate) visit(item, depth + 1);
+      return;
+    }
+    if (typeof candidate === "object") {
+      for (const [key, item] of Object.entries(candidate as Record<string, unknown>)) {
+        if (utf8Bytes(key) > KNOWLEDGE_TOPIC_MAX_BYTES) valid = false;
+        visit(item, depth + 1);
+      }
+      return;
+    }
+    valid = false;
+  };
+  visit(value, 0);
+  if (!valid) return false;
+  try {
+    return utf8Bytes(JSON.stringify(value)) <= KNOWLEDGE_METADATA_MAX_BYTES;
+  } catch {
+    return false;
+  }
+}
+
+export const KnowledgeRecordId = z
+  .string()
+  .regex(
+    /^(document|document_chunk):[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,
+  );
+export type KnowledgeRecordId = z.infer<typeof KnowledgeRecordId>;
+
+export const KnowledgeRecordKind = z.enum(["document", "document_chunk"]);
+export type KnowledgeRecordKind = z.infer<typeof KnowledgeRecordKind>;
+
+export const KnowledgeAuthority = z.object({
+  kind: z.enum(["organization", "workspace", "personal"]),
+});
+export type KnowledgeAuthority = z.infer<typeof KnowledgeAuthority>;
+
+export const KnowledgeSource = z.object({
+  kind: z.enum([
+    "manual_upload",
+    "meeting_transcript",
+    "repository",
+    "email",
+    "chat",
+    "document",
+    "web",
+    "other",
+  ]),
+  uri: boundedUtf8(KNOWLEDGE_SOURCE_URI_MAX_BYTES).pipe(z.string().min(1)).nullable(),
+  externalId: boundedUtf8(KNOWLEDGE_SOURCE_STRING_MAX_BYTES).nullable(),
+  title: boundedUtf8(KNOWLEDGE_SOURCE_STRING_MAX_BYTES).nullable(),
+  author: boundedUtf8(KNOWLEDGE_SOURCE_STRING_MAX_BYTES).nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  version: boundedUtf8(KNOWLEDGE_SOURCE_STRING_MAX_BYTES).nullable(),
+});
+export type KnowledgeSource = z.infer<typeof KnowledgeSource>;
+
+export const KnowledgeLinkTarget = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("knowledge"),
+    id: KnowledgeRecordId,
+  }),
+  z.object({
+    kind: z.literal("external"),
+    uri: boundedUtf8(KNOWLEDGE_SOURCE_URI_MAX_BYTES).pipe(z.string().min(1)),
+  }),
+]);
+export type KnowledgeLinkTarget = z.infer<typeof KnowledgeLinkTarget>;
+
+export const KnowledgeLink = z.object({
+  relation: z.enum(["parent", "contents", "previous", "next", "source"]),
+  target: KnowledgeLinkTarget,
+});
+export type KnowledgeLink = z.infer<typeof KnowledgeLink>;
+
+/**
+ * Permission-safe agent projection over one flexible knowledge record. Scope,
+ * provenance, lifecycle, and stable identity are strict. The body and metadata
+ * stay source-shaped so varied company knowledge does not require one rigid
+ * taxonomy. Personal subject ids and inaccessible linked-record metadata are
+ * deliberately absent.
+ */
+export const KnowledgeRecord = z.object({
+  id: KnowledgeRecordId,
+  kind: KnowledgeRecordKind,
+  title: boundedUtf8(KNOWLEDGE_TITLE_MAX_BYTES),
+  content: z.object({
+    format: z.literal("markdown"),
+    body: boundedUtf8(KNOWLEDGE_BODY_MAX_BYTES).nullable(),
+    summary: boundedUtf8(KNOWLEDGE_SUMMARY_MAX_BYTES).nullable(),
+    topics: z.array(boundedUtf8(KNOWLEDGE_TOPIC_MAX_BYTES)).max(KNOWLEDGE_TOPICS_MAX_ITEMS),
+    metadata: z.record(z.string(), z.unknown()).refine(boundedJson, {
+      message: "knowledge metadata exceeds its JSON projection boundary",
+    }),
+  }),
+  authority: KnowledgeAuthority,
+  provenance: z.object({
+    source: KnowledgeSource,
+    indexedAt: z.string(),
+  }),
+  lifecycle: z.object({
+    state: z.literal("active"),
+    updatedAt: z.string(),
+  }),
+  quality: z.object({
+    trust: z.literal("sourced"),
+    freshnessAt: z.string(),
+    conflict: z.literal("not_evaluated"),
+    correction: z.literal("current_source_version"),
+  }),
+  links: z.array(KnowledgeLink).max(8),
+  projection: z.object({
+    truncated: z.boolean(),
+    fields: z
+      .array(
+        z.enum([
+          "title",
+          "content.body",
+          "content.summary",
+          "content.topics",
+          "content.metadata",
+          "provenance.source.uri",
+          "provenance.source.externalId",
+          "provenance.source.title",
+          "provenance.source.author",
+          "provenance.source.version",
+        ]),
+      )
+      .max(10),
+  }),
+});
+export type KnowledgeRecord = z.infer<typeof KnowledgeRecord>;
+
+export const KnowledgeSearchResult = z.object({
+  record: KnowledgeRecord,
+  retrieval: z.object({
+    score: z.number(),
+    matchType: z.enum(["hybrid", "vector", "keyword"]),
+    vectorScore: z.number().nullable(),
+    keywordScore: z.number().nullable(),
+  }),
+});
+export type KnowledgeSearchResult = z.infer<typeof KnowledgeSearchResult>;
+
+export const KnowledgeSearchResponse = z.object({
+  results: z.array(KnowledgeSearchResult),
+});
+export type KnowledgeSearchResponse = z.infer<typeof KnowledgeSearchResponse>;
+
+export const KnowledgeGetResponse = z.object({
+  record: KnowledgeRecord,
+});
+export type KnowledgeGetResponse = z.infer<typeof KnowledgeGetResponse>;
+
+export const KnowledgeBrowseResponse = z.object({
+  records: z.array(KnowledgeRecord),
+  nextCursor: z.string().min(1).max(KNOWLEDGE_BROWSE_CURSOR_MAX_CHARS).nullable(),
+  hasMore: z.boolean(),
+});
+export type KnowledgeBrowseResponse = z.infer<typeof KnowledgeBrowseResponse>;

package/src/slack-task-policy.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+
+export const SLACK_TASK_POLICY_ID_MAX_CHARS = 128;
+export const SLACK_TASK_POLICY_REASON_MAX_CHARS = 4_096;
+export const SLACK_TASK_POLICY_MAX_IDS = 256;
+
+const SlackOpaqueId = z.string().min(1).max(SLACK_TASK_POLICY_ID_MAX_CHARS);
+
+export const SlackSharedConversationMode = z.enum(["deny", "private_handoff"]);
+export type SlackSharedConversationMode = z.infer<typeof SlackSharedConversationMode>;
+
+export const SlackResultPublicationMode = z.enum(["never", "approval_required", "allow"]);
+export type SlackResultPublicationMode = z.infer<typeof SlackResultPublicationMode>;
+
+function uniqueSortedIds(values: string[]): string[] {
+  return [...new Set(values)].sort();
+}
+
+export const SlackTaskPolicyContent = z
+  .object({
+    allowedTeamIds: z
+      .array(SlackOpaqueId)
+      .max(SLACK_TASK_POLICY_MAX_IDS)
+      .transform(uniqueSortedIds),
+    allowedConversationIds: z
+      .array(SlackOpaqueId)
+      .max(SLACK_TASK_POLICY_MAX_IDS)
+      .transform(uniqueSortedIds),
+    allowGuestInitiators: z.boolean(),
+    allowExternalInitiators: z.boolean(),
+    allowMpim: z.boolean(),
+    sharedConversationMode: SlackSharedConversationMode,
+    resultPublicationMode: SlackResultPublicationMode,
+  })
+  .strict();
+export type SlackTaskPolicyContent = z.infer<typeof SlackTaskPolicyContent>;
+
+export const DEFAULT_SLACK_TASK_POLICY: SlackTaskPolicyContent = Object.freeze({
+  allowedTeamIds: [],
+  allowedConversationIds: [],
+  allowGuestInitiators: false,
+  allowExternalInitiators: false,
+  allowMpim: false,
+  sharedConversationMode: "deny",
+  resultPublicationMode: "never",
+});
+
+export function canonicalizeSlackTaskPolicy(value: SlackTaskPolicyContent): SlackTaskPolicyContent {
+  const parsed = SlackTaskPolicyContent.parse(value);
+  return {
+    allowedTeamIds: parsed.allowedTeamIds,
+    allowedConversationIds: parsed.allowedConversationIds,
+    allowGuestInitiators: parsed.allowGuestInitiators,
+    allowExternalInitiators: parsed.allowExternalInitiators,
+    allowMpim: parsed.allowMpim,
+    sharedConversationMode: parsed.sharedConversationMode,
+    resultPublicationMode: parsed.resultPublicationMode,
+  };
+}
+
+export const SlackTaskPolicyRevisionIdentity = z.object({
+  id: z.string().uuid(),
+  revision: z.number().int().positive(),
+  policyHash: z.string().regex(/^[0-9a-f]{64}$/),
+});
+export type SlackTaskPolicyRevisionIdentity = z.infer<typeof SlackTaskPolicyRevisionIdentity>;
+
+export const SlackTaskPolicyRevision = SlackTaskPolicyRevisionIdentity.extend({
+  operationId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  policy: SlackTaskPolicyContent,
+  supersedesRevisionId: z.string().uuid().nullable(),
+  createdBySubjectId: z.string().min(1).max(1_024),
+  createdAt: z.string().datetime(),
+});
+export type SlackTaskPolicyRevision = z.infer<typeof SlackTaskPolicyRevision>;
+
+export const SlackTaskPolicyHead = z.object({
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  revisionId: z.string().uuid(),
+  revision: z.number().int().positive(),
+  policyHash: z.string().regex(/^[0-9a-f]{64}$/),
+  activationVersion: z.number().int().positive(),
+  activatedAt: z.string().datetime(),
+});
+export type SlackTaskPolicyHead = z.infer<typeof SlackTaskPolicyHead>;
+
+export const SlackTaskPolicyActivationEvent = z.object({
+  id: z.string().uuid(),
+  operationId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  activationVersion: z.number().int().positive(),
+  oldRevision: SlackTaskPolicyRevisionIdentity.nullable(),
+  newRevision: SlackTaskPolicyRevisionIdentity,
+  actorSubjectId: z.string().min(1).max(1_024),
+  reason: z.string().min(1).max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
+  createdAt: z.string().datetime(),
+});
+export type SlackTaskPolicyActivationEvent = z.infer<typeof SlackTaskPolicyActivationEvent>;
+
+export const SlackTaskPolicyListResponse = z.object({
+  current: SlackTaskPolicyHead.nullable(),
+  activeRevision: SlackTaskPolicyRevision.nullable(),
+  revisions: z.array(SlackTaskPolicyRevision),
+  activationEvents: z.array(SlackTaskPolicyActivationEvent),
+});
+export type SlackTaskPolicyListResponse = z.infer<typeof SlackTaskPolicyListResponse>;
+
+export const UpdateSlackTaskPolicyRequest = z.object({
+  operationId: z.string().uuid().optional(),
+  policy: SlackTaskPolicyContent,
+  expectedCurrentRevisionId: z.string().uuid().nullable(),
+  expectedActivationVersion: z.number().int().nonnegative(),
+  reason: z.string().trim().min(1).max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
+});
+export type UpdateSlackTaskPolicyRequest = z.infer<typeof UpdateSlackTaskPolicyRequest>;
+
+export const SlackTaskPolicyMutationResponse = z.object({
+  revision: SlackTaskPolicyRevision,
+  head: SlackTaskPolicyHead,
+  event: SlackTaskPolicyActivationEvent,
+});
+export type SlackTaskPolicyMutationResponse = z.infer<typeof SlackTaskPolicyMutationResponse>;
+
+export type SlackTaskPolicyConversationFacts = Readonly<{
+  installationTeamId: string;
+  conversationId: string;
+  contextTeamId: string | null;
+  connectedTeamIds: readonly string[] | null;
+  sharedTeamIds: readonly string[] | null;
+  isShared: boolean;
+  isExternallyShared: boolean;
+  isOrgShared: boolean;
+  isPendingExternallyShared: boolean;
+  isMpim: boolean;
+}>;
+
+export type SlackTaskPolicyInitiatorFacts = Readonly<{
+  teamId: string | null;
+  isGuest: boolean | null;
+  isExternal: boolean | null;
+}>;
+
+export type SlackTaskPolicyDecision = Readonly<{
+  disposition: "ordinary" | "deny" | "private_handoff";
+  publication: SlackResultPublicationMode;
+  reason:
+    | "ordinary_conversation"
+    | "policy_missing"
+    | "conversation_not_allowed"
+    | "team_not_allowed"
+    | "ambiguous_shared_facts"
+    | "mpim_not_allowed"
+    | "guest_not_allowed"
+    | "external_not_allowed"
+    | "allowed";
+}>;
+
+export function evaluateSlackTaskPolicy(input: {
+  policy: SlackTaskPolicyContent | null;
+  conversation: SlackTaskPolicyConversationFacts;
+  initiator: SlackTaskPolicyInitiatorFacts;
+}): SlackTaskPolicyDecision {
+  const { conversation, initiator } = input;
+  const governed =
+    conversation.isShared ||
+    conversation.isExternallyShared ||
+    conversation.isOrgShared ||
+    conversation.isPendingExternallyShared ||
+    conversation.isMpim;
+  if (!governed) {
+    return { disposition: "ordinary", publication: "allow", reason: "ordinary_conversation" };
+  }
+  if (!input.policy) return { disposition: "deny", publication: "never", reason: "policy_missing" };
+  const policy = canonicalizeSlackTaskPolicy(input.policy);
+  if (!policy.allowedConversationIds.includes(conversation.conversationId)) {
+    return { disposition: "deny", publication: "never", reason: "conversation_not_allowed" };
+  }
+  if (conversation.isMpim && !policy.allowMpim) {
+    return { disposition: "deny", publication: "never", reason: "mpim_not_allowed" };
+  }
+  if (initiator.isGuest === null || initiator.isExternal === null || initiator.teamId === null) {
+    return { disposition: "deny", publication: "never", reason: "ambiguous_shared_facts" };
+  }
+  if (initiator.isGuest && !policy.allowGuestInitiators) {
+    return { disposition: "deny", publication: "never", reason: "guest_not_allowed" };
+  }
+  if (initiator.isExternal && !policy.allowExternalInitiators) {
+    return { disposition: "deny", publication: "never", reason: "external_not_allowed" };
+  }
+  const teams = [
+    conversation.installationTeamId,
+    conversation.contextTeamId,
+    initiator.teamId,
+    ...(conversation.connectedTeamIds ?? []),
+    ...(conversation.sharedTeamIds ?? []),
+  ];
+  if (conversation.connectedTeamIds === null || conversation.sharedTeamIds === null) {
+    return { disposition: "deny", publication: "never", reason: "ambiguous_shared_facts" };
+  }
+  if (teams.some((teamId) => teamId === null || !policy.allowedTeamIds.includes(teamId))) {
+    return { disposition: "deny", publication: "never", reason: "team_not_allowed" };
+  }
+  if (policy.sharedConversationMode === "deny") {
+    return { disposition: "deny", publication: "never", reason: "allowed" };
+  }
+  return {
+    disposition: "private_handoff",
+    publication: policy.resultPublicationMode,
+    reason: "allowed",
+  };
+}

package/src/task-notes.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+export const TASK_NOTE_TEXT_MAX_BYTES = 4_096;
+export const TASK_NOTE_REASON_MAX_BYTES = 2_048;
+export const TASK_NOTE_MAX_LIFETIME_DAYS = 30;
+export const TASK_NOTE_ACTIVE_RECORD_CAP = 500;
+export const TASK_NOTE_LIST_DEFAULT_LIMIT = 10;
+export const TASK_NOTE_LIST_MAX_LIMIT = 20;
+export const TASK_NOTE_LIST_RESPONSE_MAX_BYTES = 96 * 1_024;
+
+const utf8Bytes = (value: string): number => new TextEncoder().encode(value).byteLength;
+
+export function boundedTaskNoteText(maxBytes: number, label: string) {
+  return z
+    .string()
+    .min(1)
+    .superRefine((value, ctx) => {
+      if (value !== value.trim()) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `${label} must not have leading or trailing whitespace`,
+        });
+      }
+      if (utf8Bytes(value) > maxBytes) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `${label} must be at most ${maxBytes} UTF-8 bytes`,
+        });
+      }
+    });
+}
+
+export const TaskNoteText = boundedTaskNoteText(TASK_NOTE_TEXT_MAX_BYTES, "task note text");
+export const TaskNoteReason = boundedTaskNoteText(
+  TASK_NOTE_REASON_MAX_BYTES,
+  "task note archive reason",
+);
+
+export const TaskNoteKind = z.enum([
+  "finding",
+  "decision",
+  "blocker",
+  "ownership",
+  "artifact",
+  "handoff",
+]);
+export type TaskNoteKind = z.infer<typeof TaskNoteKind>;
+
+export const TaskNoteStatus = z.enum(["active", "archived"]);
+export type TaskNoteStatus = z.infer<typeof TaskNoteStatus>;
+
+export const TaskNoteActorKind = z.enum(["human", "service"]);
+export type TaskNoteActorKind = z.infer<typeof TaskNoteActorKind>;
+
+export const TaskNote = z.object({
+  id: z.string().uuid(),
+  rootSessionId: z.string().uuid(),
+  kind: TaskNoteKind,
+  text: TaskNoteText,
+  status: TaskNoteStatus,
+  version: z.number().int().positive(),
+  expiresAt: z.string().datetime({ offset: true }),
+  createdAt: z.string().datetime({ offset: true }),
+  updatedAt: z.string().datetime({ offset: true }),
+  archivedAt: z.string().datetime({ offset: true }).nullable(),
+  provenance: z.object({
+    actorKind: TaskNoteActorKind,
+    sourceSessionId: z.string().uuid(),
+    sourceTurnId: z.string().uuid(),
+  }),
+});
+export type TaskNote = z.infer<typeof TaskNote>;
+
+export const TaskNoteMutationResult = z.object({
+  note: TaskNote,
+  replayed: z.boolean(),
+});
+export type TaskNoteMutationResult = z.infer<typeof TaskNoteMutationResult>;
+
+export const TaskNoteListResponse = z
+  .object({
+    notes: z.array(TaskNote).max(TASK_NOTE_LIST_MAX_LIMIT),
+  })
+  .superRefine((value, ctx) => {
+    if (utf8Bytes(JSON.stringify(value)) > TASK_NOTE_LIST_RESPONSE_MAX_BYTES) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `task note list response must be at most ${TASK_NOTE_LIST_RESPONSE_MAX_BYTES} UTF-8 bytes`,
+      });
+    }
+  });
+export type TaskNoteListResponse = z.infer<typeof TaskNoteListResponse>;

package/src/video-generation.ts

@@ -7,6 +7,7 @@ import {
 
 export const VIDEO_GENERATION_SCHEMA_VERSION = 1 as const;
 export const SEEDANCE_2_5_MODEL_ID = "bytedance/seedance-2.5" as const;
+export const GROK_IMAGINE_VIDEO_1_5_MODEL_ID = "xai/grok-imagine-video-1.5" as const;
 
 export const VideoGenerationSourceMode = z.enum([
   "text",
@@ -20,7 +21,11 @@ export type VideoGenerationSourceMode = z.infer<typeof VideoGenerationSourceMode
 export const VideoGenerationResolution = z.enum(["480p", "720p"]);
 export type VideoGenerationResolution = z.infer<typeof VideoGenerationResolution>;
 
-export const VideoGenerationFundingSource = z.enum(["opengeni_credits", "workspace_gateway"]);
+export const VideoGenerationFundingSource = z.enum([
+  "opengeni_credits",
+  "workspace_gateway",
+  "supergrok_subscription",
+]);
 export type VideoGenerationFundingSource = z.infer<typeof VideoGenerationFundingSource>;
 
 export const VideoGenerationAspectRatio = z.enum([
@@ -131,7 +136,11 @@ export const VideoGenerationCapabilities = z
   .superRefine((value, ctx) => {
     const ids = new Set(value.models.map((model) => model.modelId));
     if (ids.size !== value.models.length) {
-      ctx.addIssue({ code: "custom", path: ["models"], message: "model ids must be unique" });
+      ctx.addIssue({
+        code: "custom",
+        path: ["models"],
+        message: "model ids must be unique",
+      });
     }
     if (!ids.has(value.defaultModelId)) {
       ctx.addIssue({
@@ -205,21 +214,22 @@ export const WorkspaceVideoGenerationSettings = z
   .object({
     schemaVersion: z.literal(VIDEO_GENERATION_SCHEMA_VERSION),
     policy: VideoGenerationPolicy,
-    fundingOptions: z.array(VideoGenerationFundingOption).length(2),
+    fundingOptions: z.array(VideoGenerationFundingOption).length(3),
     availableModels: z.array(VideoGenerationModelCapability).max(16),
     capabilities: VideoGenerationCapabilities.nullable(),
   })
   .strict()
   .superRefine((value, ctx) => {
     if (
-      new Set(value.fundingOptions.map((option) => option.source)).size !== 2 ||
+      new Set(value.fundingOptions.map((option) => option.source)).size !== 3 ||
       !value.fundingOptions.some((option) => option.source === "opengeni_credits") ||
-      !value.fundingOptions.some((option) => option.source === "workspace_gateway")
+      !value.fundingOptions.some((option) => option.source === "workspace_gateway") ||
+      !value.fundingOptions.some((option) => option.source === "supergrok_subscription")
     ) {
       ctx.addIssue({
         code: "custom",
         path: ["fundingOptions"],
-        message: "both funding sources must be described exactly once",
+        message: "all funding sources must be described exactly once",
       });
     }
     const selected = value.fundingOptions.find(
@@ -250,6 +260,33 @@ export const VideoGenerationAcceptedReceipt = z
   .strict();
 export type VideoGenerationAcceptedReceipt = z.infer<typeof VideoGenerationAcceptedReceipt>;
 
+export const VideoGenerationRejectedCode = z.enum([
+  "invalid_reference_path",
+  "reference_not_stable",
+  "reference_too_large",
+  "reference_media_type_mismatch",
+  "unsupported_reference_media",
+]);
+export type VideoGenerationRejectedCode = z.infer<typeof VideoGenerationRejectedCode>;
+
+/** Deterministic pre-admission rejection: no provider request or durable operation was created. */
+export const VideoGenerationRejectedResult = z
+  .object({
+    schemaVersion: z.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    status: z.literal("rejected"),
+    code: VideoGenerationRejectedCode,
+    message: z.string().min(1).max(512),
+    operationCreated: z.literal(false),
+  })
+  .strict();
+export type VideoGenerationRejectedResult = z.infer<typeof VideoGenerationRejectedResult>;
+
+export const VideoGenerationToolResult = z.discriminatedUnion("status", [
+  VideoGenerationAcceptedReceipt,
+  VideoGenerationRejectedResult,
+]);
+export type VideoGenerationToolResult = z.infer<typeof VideoGenerationToolResult>;
+
 export const GeneratedVideoFacts = z
   .object({
     durationSeconds: z.number().positive().max(120),

package/src/xai-provider-account-authority.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+const PositiveSafeInteger = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+
+/**
+ * Opaque authority frozen at an xAI provider-account acceptance boundary.
+ *
+ * This snapshot deliberately carries no organization, membership, credential,
+ * provider-account, subject, label, quota, token, or plan identity. User scope
+ * becomes executable only after exact live database revalidation against the
+ * separately stored causal subject and xAI subscription authority row.
+ */
+export const XaiProviderAccountAuthoritySnapshotV1 = z.discriminatedUnion("scope", [
+  z
+    .object({
+      version: z.literal(1),
+      scope: z.literal("workspace"),
+    })
+    .strict(),
+  z
+    .object({
+      version: z.literal(1),
+      scope: z.literal("user"),
+      authorityGeneration: PositiveSafeInteger,
+    })
+    .strict(),
+]);
+
+export type XaiProviderAccountAuthoritySnapshotV1 = z.infer<
+  typeof XaiProviderAccountAuthoritySnapshotV1
+>;
+
+/** Explicit compatibility value for workspace-default accepted work. */
+export const WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1 = {
+  version: 1,
+  scope: "workspace",
+} as const satisfies XaiProviderAccountAuthoritySnapshotV1;