@opengeni/contracts 0.31.1 → 0.35.0

package/dist/workspace-instruction-policies.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const WORKSPACE_INSTRUCTION_POLICY_CONTENT_MAX_CHARS = 262144;
+export declare const WORKSPACE_INSTRUCTION_POLICY_PROMPT_MAX_UTF8_BYTES = 131072;
 export declare const WORKSPACE_INSTRUCTION_POLICY_REASON_MAX_CHARS = 4096;
 export declare const WORKSPACE_INSTRUCTION_POLICY_ROLE_KEY_MAX_CHARS = 64;
 export declare const WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS = 512;
@@ -38,6 +39,15 @@ export type WorkspaceInstructionPolicyRoleKey = z.infer<typeof WorkspaceInstruct
  * at ingress so activation uniqueness and every client use the same key.
  */
 export declare function normalizeWorkspaceInstructionPolicyRoleKey(value: string): string;
+export declare const WorkspaceInstructionPolicyRoleKeyInput: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+export type WorkspaceInstructionPolicyRoleKeyInput = z.infer<typeof WorkspaceInstructionPolicyRoleKeyInput>;
+export declare const WorkspaceInstructionPolicyRoleSource: z.ZodEnum<{
+    invalid_metadata_fallback: "invalid_metadata_fallback";
+    metadata_fallback: "metadata_fallback";
+    none: "none";
+    session_binding: "session_binding";
+}>;
+export type WorkspaceInstructionPolicyRoleSource = z.infer<typeof WorkspaceInstructionPolicyRoleSource>;
 export declare const WorkspaceInstructionPolicyTarget: z.ZodObject<{
     kind: z.ZodEnum<{
         charter: "charter";
@@ -79,6 +89,7 @@ export declare const WorkspaceInstructionPolicyRevision: z.ZodObject<{
     id: z.ZodString;
     revision: z.ZodNumber;
     contentHash: z.ZodString;
+    operationId: z.ZodString;
     accountId: z.ZodString;
     workspaceId: z.ZodString;
     content: z.ZodString;
@@ -114,6 +125,156 @@ export declare const WorkspaceInstructionPolicyHead: z.ZodObject<{
     activatedAt: z.ZodString;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyHead = z.infer<typeof WorkspaceInstructionPolicyHead>;
+export declare const WorkspaceInstructionPolicySnapshotProvenance: z.ZodObject<{
+    source: z.ZodEnum<{
+        human: "human";
+        knowledge_proposal: "knowledge_proposal";
+        legacy_import: "legacy_import";
+        onboarding: "onboarding";
+    }>;
+    sourceIdHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicySnapshotProvenance = z.infer<typeof WorkspaceInstructionPolicySnapshotProvenance>;
+export declare const WorkspaceInstructionPolicySnapshotEntry: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    revisionId: z.ZodString;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+    activationVersion: z.ZodNumber;
+    activatedAt: z.ZodString;
+    provenance: z.ZodObject<{
+        source: z.ZodEnum<{
+            human: "human";
+            knowledge_proposal: "knowledge_proposal";
+            legacy_import: "legacy_import";
+            onboarding: "onboarding";
+        }>;
+        sourceIdHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicySnapshotEntry = z.infer<typeof WorkspaceInstructionPolicySnapshotEntry>;
+export declare const WorkspaceInstructionPolicySnapshot: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    policyRole: z.ZodNullable<z.ZodString>;
+    roleSource: z.ZodEnum<{
+        invalid_metadata_fallback: "invalid_metadata_fallback";
+        metadata_fallback: "metadata_fallback";
+        none: "none";
+        session_binding: "session_binding";
+    }>;
+    entryHash: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodEnum<{
+                human: "human";
+                knowledge_proposal: "knowledge_proposal";
+                legacy_import: "legacy_import";
+                onboarding: "onboarding";
+            }>;
+            sourceIdHash: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicySnapshot = z.infer<typeof WorkspaceInstructionPolicySnapshot>;
+export declare const ResolvedWorkspaceInstructionPolicySnapshotEntry: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    revisionId: z.ZodString;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+    activationVersion: z.ZodNumber;
+    activatedAt: z.ZodString;
+    provenance: z.ZodObject<{
+        source: z.ZodEnum<{
+            human: "human";
+            knowledge_proposal: "knowledge_proposal";
+            legacy_import: "legacy_import";
+            onboarding: "onboarding";
+        }>;
+        sourceIdHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type ResolvedWorkspaceInstructionPolicySnapshotEntry = z.infer<typeof ResolvedWorkspaceInstructionPolicySnapshotEntry>;
+export declare const ResolvedWorkspaceInstructionPolicySnapshot: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    policyRole: z.ZodNullable<z.ZodString>;
+    roleSource: z.ZodEnum<{
+        invalid_metadata_fallback: "invalid_metadata_fallback";
+        metadata_fallback: "metadata_fallback";
+        none: "none";
+        session_binding: "session_binding";
+    }>;
+    entryHash: z.ZodString;
+    createdAt: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodEnum<{
+                human: "human";
+                knowledge_proposal: "knowledge_proposal";
+                legacy_import: "legacy_import";
+                onboarding: "onboarding";
+            }>;
+            sourceIdHash: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ResolvedWorkspaceInstructionPolicySnapshot = z.infer<typeof ResolvedWorkspaceInstructionPolicySnapshot>;
 export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
     kind: z.ZodEnum<{
         charter: "charter";
@@ -125,6 +286,7 @@ export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
     }>;
     roleKey: z.ZodNullable<z.ZodString>;
     id: z.ZodString;
+    operationId: z.ZodString;
     accountId: z.ZodString;
     workspaceId: z.ZodString;
     type: z.ZodEnum<{
@@ -148,6 +310,7 @@ export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyActivationEvent = z.infer<typeof WorkspaceInstructionPolicyActivationEvent>;
 export declare const CreateWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
         charter: "charter";
         policy: "policy";
@@ -168,6 +331,7 @@ export declare const CreateWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
 }, z.core.$strip>;
 export type CreateWorkspaceInstructionPolicyDraftRequest = z.infer<typeof CreateWorkspaceInstructionPolicyDraftRequest>;
 export declare const ImportLegacyWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     supersedesRevisionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type ImportLegacyWorkspaceInstructionPolicyDraftRequest = z.infer<typeof ImportLegacyWorkspaceInstructionPolicyDraftRequest>;
@@ -199,6 +363,7 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -243,6 +408,7 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         }>;
         roleKey: z.ZodNullable<z.ZodString>;
         id: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         type: z.ZodEnum<{
@@ -286,6 +452,7 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -315,6 +482,7 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -336,13 +504,17 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyDiffResponse = z.infer<typeof WorkspaceInstructionPolicyDiffResponse>;
 export declare const ActivateWorkspaceInstructionPolicyRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     expectedCurrentRevisionId: z.ZodNullable<z.ZodString>;
+    expectedActivationVersion: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodString;
 }, z.core.$strip>;
 export type ActivateWorkspaceInstructionPolicyRequest = z.infer<typeof ActivateWorkspaceInstructionPolicyRequest>;
 export declare const RollbackWorkspaceInstructionPolicyRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     targetRevisionId: z.ZodString;
     expectedCurrentRevisionId: z.ZodString;
+    expectedActivationVersion: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodString;
 }, z.core.$strip>;
 export type RollbackWorkspaceInstructionPolicyRequest = z.infer<typeof RollbackWorkspaceInstructionPolicyRequest>;
@@ -375,6 +547,7 @@ export declare const WorkspaceInstructionPolicyActivationResponse: z.ZodObject<{
         }>;
         roleKey: z.ZodNullable<z.ZodString>;
         id: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         type: z.ZodEnum<{
@@ -420,3 +593,8 @@ export declare const WorkspaceInstructionPolicyConflictResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyConflictResponse = z.infer<typeof WorkspaceInstructionPolicyConflictResponse>;
+export declare const WorkspaceInstructionPolicyOperationReuseResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_OPERATION_REUSED">;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOperationReuseResponse = z.infer<typeof WorkspaceInstructionPolicyOperationReuseResponse>;

package/dist/workspace-state.d.ts

@@ -6,6 +6,10 @@ export declare const WORKSPACE_STATE_MAX_GAPS = 16;
 export declare const WORKSPACE_STATE_BASE_NAME_MAX_CHARS = 160;
 export declare const WORKSPACE_STATE_TOPIC_MAX_CHARS = 96;
 export declare const WORKSPACE_STATE_MEMORY_SAMPLE_LIMIT = 100;
+export declare const WorkspaceStateQuery: z.ZodObject<{
+    attemptId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkspaceStateQuery = z.infer<typeof WorkspaceStateQuery>;
 export declare const WorkspaceStateDocumentStatusCounts: z.ZodObject<{
     queued: z.ZodNumber;
     indexing: z.ZodNumber;
@@ -364,6 +368,118 @@ export declare const WorkspaceStateKnowledge: z.ZodDiscriminatedUnion<[z.ZodObje
     requiredPermission: z.ZodLiteral<"documents:search">;
 }, z.core.$strict>], "availability">;
 export type WorkspaceStateKnowledge = z.infer<typeof WorkspaceStateKnowledge>;
+export declare const WorkspaceStateGovernanceDriftStatus: z.ZodEnum<{
+    changed: "changed";
+    identical: "identical";
+    missing: "missing";
+    superseded: "superseded";
+    truncated: "truncated";
+    unavailable: "unavailable";
+}>;
+export type WorkspaceStateGovernanceDriftStatus = z.infer<typeof WorkspaceStateGovernanceDriftStatus>;
+export declare const WorkspaceStateAttemptGovernance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"not_requested">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodLiteral<"attempt_not_found_or_not_authorized">;
+    driftStatus: z.ZodLiteral<"unavailable">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    acceptedAt: z.ZodString;
+    policySnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        entryHash: z.ZodString;
+        policyRole: z.ZodNullable<z.ZodString>;
+        roleSource: z.ZodEnum<{
+            invalid_metadata_fallback: "invalid_metadata_fallback";
+            metadata_fallback: "metadata_fallback";
+            none: "none";
+            session_binding: "session_binding";
+        }>;
+        entries: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            activationVersion: z.ZodNumber;
+            activatedAt: z.ZodString;
+            provenance: z.ZodObject<{
+                source: z.ZodEnum<{
+                    human: "human";
+                    knowledge_proposal: "knowledge_proposal";
+                    legacy_import: "legacy_import";
+                    onboarding: "onboarding";
+                }>;
+                sourceIdHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "status">;
+    preferenceSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        descriptorHash: z.ZodString;
+        descriptorCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "status">;
+    drift: z.ZodObject<{
+        overall: z.ZodEnum<{
+            changed: "changed";
+            identical: "identical";
+            missing: "missing";
+            superseded: "superseded";
+            truncated: "truncated";
+            unavailable: "unavailable";
+        }>;
+        policy: z.ZodObject<{
+            status: z.ZodEnum<{
+                changed: "changed";
+                identical: "identical";
+                missing: "missing";
+                superseded: "superseded";
+                truncated: "truncated";
+                unavailable: "unavailable";
+            }>;
+            snapshotHash: z.ZodNullable<z.ZodString>;
+            currentHash: z.ZodNullable<z.ZodString>;
+            snapshotTargetCount: z.ZodNumber;
+            currentTargetCount: z.ZodNumber;
+        }, z.core.$strict>;
+        preferences: z.ZodObject<{
+            status: z.ZodEnum<{
+                changed: "changed";
+                identical: "identical";
+                missing: "missing";
+                superseded: "superseded";
+                truncated: "truncated";
+                unavailable: "unavailable";
+            }>;
+            snapshotHash: z.ZodNullable<z.ZodString>;
+            currentHash: z.ZodNullable<z.ZodString>;
+            snapshotDescriptorCount: z.ZodNumber;
+            currentDescriptorCount: z.ZodNumber;
+            snapshotTruncated: z.ZodBoolean;
+            currentTruncated: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "status">;
+export type WorkspaceStateAttemptGovernance = z.infer<typeof WorkspaceStateAttemptGovernance>;
 export declare const WorkspaceStateResponse: z.ZodObject<{
     workspaceId: z.ZodString;
     generatedAt: z.ZodString;
@@ -372,10 +488,108 @@ export declare const WorkspaceStateResponse: z.ZodObject<{
             source: z.ZodLiteral<"read_time_projection">;
             capturedAt: z.ZodString;
         }, z.core.$strict>;
-        policySnapshot: z.ZodObject<{
-            status: z.ZodLiteral<"not_captured">;
-            reason: z.ZodLiteral<"workspace_instruction_policy_snapshot_not_implemented">;
-        }, z.core.$strict>;
+        attemptGovernance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"not_requested">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodLiteral<"attempt_not_found_or_not_authorized">;
+            driftStatus: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            attemptId: z.ZodString;
+            executionGeneration: z.ZodNumber;
+            acceptedAt: z.ZodString;
+            policySnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                id: z.ZodString;
+                createdAt: z.ZodString;
+                entryHash: z.ZodString;
+                policyRole: z.ZodNullable<z.ZodString>;
+                roleSource: z.ZodEnum<{
+                    invalid_metadata_fallback: "invalid_metadata_fallback";
+                    metadata_fallback: "metadata_fallback";
+                    none: "none";
+                    session_binding: "session_binding";
+                }>;
+                entries: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        charter: "charter";
+                        policy: "policy";
+                    }>;
+                    scope: z.ZodEnum<{
+                        global: "global";
+                        role: "role";
+                    }>;
+                    roleKey: z.ZodNullable<z.ZodString>;
+                    revisionId: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                    activationVersion: z.ZodNumber;
+                    activatedAt: z.ZodString;
+                    provenance: z.ZodObject<{
+                        source: z.ZodEnum<{
+                            human: "human";
+                            knowledge_proposal: "knowledge_proposal";
+                            legacy_import: "legacy_import";
+                            onboarding: "onboarding";
+                        }>;
+                        sourceIdHash: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "status">;
+            preferenceSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                id: z.ZodString;
+                createdAt: z.ZodString;
+                descriptorHash: z.ZodString;
+                descriptorCount: z.ZodNumber;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "status">;
+            drift: z.ZodObject<{
+                overall: z.ZodEnum<{
+                    changed: "changed";
+                    identical: "identical";
+                    missing: "missing";
+                    superseded: "superseded";
+                    truncated: "truncated";
+                    unavailable: "unavailable";
+                }>;
+                policy: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        changed: "changed";
+                        identical: "identical";
+                        missing: "missing";
+                        superseded: "superseded";
+                        truncated: "truncated";
+                        unavailable: "unavailable";
+                    }>;
+                    snapshotHash: z.ZodNullable<z.ZodString>;
+                    currentHash: z.ZodNullable<z.ZodString>;
+                    snapshotTargetCount: z.ZodNumber;
+                    currentTargetCount: z.ZodNumber;
+                }, z.core.$strict>;
+                preferences: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        changed: "changed";
+                        identical: "identical";
+                        missing: "missing";
+                        superseded: "superseded";
+                        truncated: "truncated";
+                        unavailable: "unavailable";
+                    }>;
+                    snapshotHash: z.ZodNullable<z.ZodString>;
+                    currentHash: z.ZodNullable<z.ZodString>;
+                    snapshotDescriptorCount: z.ZodNumber;
+                    currentDescriptorCount: z.ZodNumber;
+                    snapshotTruncated: z.ZodBoolean;
+                    currentTruncated: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "status">;
     }, z.core.$strict>;
     policy: z.ZodObject<{
         authority: z.ZodLiteral<"workspace_instruction_policy_heads">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.31.1",
+  "version": "0.35.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {

package/src/google-drive.ts

@@ -3,6 +3,8 @@ import { z } from "zod";
 import { ConnectionMetadata } from "./index";
 
 export const GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com" as const;
+export const GOOGLE_DRIVE_FULL_SCOPE = "https://www.googleapis.com/auth/drive" as const;
+export const GOOGLE_DRIVE_FILE_SCOPE = "https://www.googleapis.com/auth/drive.file" as const;
 export const GOOGLE_DRIVE_METADATA_READONLY_SCOPE =
   "https://www.googleapis.com/auth/drive.metadata.readonly" as const;
 export const GOOGLE_DRIVE_READONLY_SCOPE =
@@ -10,6 +12,57 @@ export const GOOGLE_DRIVE_READONLY_SCOPE =
 export const GOOGLE_DRIVE_CREDENTIAL_ROLE = "google_drive_metadata" as const;
 export const GOOGLE_DRIVE_CREDENTIAL_LABEL = "Google Drive metadata browser" as const;
 
+export const GoogleDriveOAuthCapability = z.enum([
+  "picker_file_read",
+  "source_metadata_discovery",
+  "source_content_read",
+  "recursive_source_sync",
+]);
+export type GoogleDriveOAuthCapability = z.infer<typeof GoogleDriveOAuthCapability>;
+
+export type GoogleDriveOAuthScopeDecision = {
+  accessMode: "metadata_readonly" | "readonly" | null;
+  capabilities: GoogleDriveOAuthCapability[];
+};
+
+/**
+ * Converts exact Google OAuth grants into the Drive capabilities OpenGeni may
+ * rely on. Unknown or malformed grants add no authority. In particular,
+ * drive.file covers only files explicitly opened or shared with the app and
+ * never authorizes arbitrary recursive descendant discovery.
+ */
+export function googleDriveOAuthScopeDecision(
+  grantedScopes: readonly string[],
+): GoogleDriveOAuthScopeDecision {
+  const granted = new Set(grantedScopes);
+  const hasFullDrive = granted.has(GOOGLE_DRIVE_FULL_SCOPE);
+  const hasSourceContentRead = hasFullDrive || granted.has(GOOGLE_DRIVE_READONLY_SCOPE);
+  const hasSourceMetadataDiscovery =
+    hasSourceContentRead || granted.has(GOOGLE_DRIVE_METADATA_READONLY_SCOPE);
+  const hasPickerFileRead = hasSourceContentRead || granted.has(GOOGLE_DRIVE_FILE_SCOPE);
+  const capabilities: GoogleDriveOAuthCapability[] = [];
+  if (hasPickerFileRead) capabilities.push("picker_file_read");
+  if (hasSourceMetadataDiscovery) capabilities.push("source_metadata_discovery");
+  if (hasSourceContentRead) {
+    capabilities.push("source_content_read", "recursive_source_sync");
+  }
+  return {
+    accessMode: hasSourceContentRead
+      ? "readonly"
+      : hasSourceMetadataDiscovery
+        ? "metadata_readonly"
+        : null,
+    capabilities,
+  };
+}
+
+export function googleDriveScopesAllowCapability(
+  grantedScopes: readonly string[],
+  capability: GoogleDriveOAuthCapability,
+): boolean {
+  return googleDriveOAuthScopeDecision(grantedScopes).capabilities.includes(capability);
+}
+
 export const GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
 export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
 
@@ -19,6 +72,59 @@ export type GoogleDriveSyncCadence = z.infer<typeof GoogleDriveSyncCadence>;
 export const GoogleDriveReadPolicy = z.enum(["allow", "ask", "block"]);
 export type GoogleDriveReadPolicy = z.infer<typeof GoogleDriveReadPolicy>;
 
+export const GoogleDriveConnectionLifecycleState = z.enum([
+  "active",
+  "paused",
+  "token_revoked",
+  "app_removed",
+  "disconnected",
+  "reconnect_required",
+  "reconsent_required",
+]);
+export type GoogleDriveConnectionLifecycleState = z.infer<
+  typeof GoogleDriveConnectionLifecycleState
+>;
+
+const GoogleDriveLifecycleObservedAt = z.string().datetime({ offset: true });
+export const GoogleDriveConnectionLifecycle = z.discriminatedUnion("state", [
+  z.object({
+    state: z.literal("active"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("paused"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("token_revoked"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("app_removed"),
+    recoverable: z.literal(false),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("disconnected"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("reconnect_required"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("reconsent_required"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+]);
+export type GoogleDriveConnectionLifecycle = z.infer<typeof GoogleDriveConnectionLifecycle>;
+
 export const GoogleDriveSelectedSource = z.object({
   id: z.string().min(1).max(256),
   name: z.string().min(1).max(1024),
@@ -40,6 +146,7 @@ export const GoogleDriveConnectionMetadata = z
     googleDisplayName: z.string().min(1).max(512).nullable(),
     verifiedAt: z.string().datetime({ offset: true }),
     accessMode: z.enum(["metadata_readonly", "readonly"]),
+    lifecycle: GoogleDriveConnectionLifecycle.optional(),
     selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
     /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
     selectedSource: GoogleDriveSelectedSource.nullable().optional(),
@@ -58,6 +165,18 @@ export const GoogleDriveOAuthStartResponse = z.object({
 });
 export type GoogleDriveOAuthStartResponse = z.infer<typeof GoogleDriveOAuthStartResponse>;
 
+export const GoogleDriveLifecycleActionRequest = z.object({
+  action: z.enum(["pause", "resume"]),
+  expectedVersion: z.number().int().positive(),
+});
+export type GoogleDriveLifecycleActionRequest = z.infer<typeof GoogleDriveLifecycleActionRequest>;
+
+export const GoogleDriveDisconnectRequest = z.object({
+  expectedVersion: z.number().int().positive(),
+  idempotencyKey: z.string().trim().min(1).max(200),
+});
+export type GoogleDriveDisconnectRequest = z.infer<typeof GoogleDriveDisconnectRequest>;
+
 export const GoogleDriveBrowseItem = z.object({
   id: z.string().min(1).max(256),
   name: z.string().min(1).max(1024),