@opengeni/contracts 0.36.0 → 0.38.1

package/dist/workspace-state.d.ts

@@ -6,6 +6,7 @@ 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 WORKSPACE_STATE_EXPORT_SCHEMA_VERSION = 1;
 export declare const WorkspaceStateQuery: z.ZodObject<{
     attemptId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
@@ -28,6 +29,12 @@ export declare const WorkspaceStateSourceKindCounts: z.ZodObject<{
     other: z.ZodNumber;
 }, z.core.$strict>;
 export type WorkspaceStateSourceKindCounts = z.infer<typeof WorkspaceStateSourceKindCounts>;
+export declare const WorkspaceStateDocumentAuthorityKindCounts: z.ZodObject<{
+    organization: z.ZodNumber;
+    workspace: z.ZodNumber;
+    personal: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceStateDocumentAuthorityKindCounts = z.infer<typeof WorkspaceStateDocumentAuthorityKindCounts>;
 export declare const WorkspaceStateMemoryStatusCounts: z.ZodObject<{
     proposed: z.ZodNumber;
     approved: z.ZodNumber;
@@ -141,6 +148,17 @@ export declare const WorkspaceStatePolicy: z.ZodObject<{
         status: z.ZodLiteral<"not_implemented">;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const WorkspaceStatePreferences: z.ZodObject<{
+    authority: z.ZodLiteral<"preference_registry_preferences">;
+    activeDescriptorCount: z.ZodNumber;
+    activeDescriptorHash: z.ZodString;
+    scopeCounts: z.ZodObject<{
+        organization: z.ZodNumber;
+        workspace: z.ZodNumber;
+        user: z.ZodNumber;
+    }, z.core.$strict>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>;
 export declare const WorkspaceStateKnowledgeBase: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -223,6 +241,11 @@ export declare const WorkspaceStateKnowledgeAvailable: z.ZodObject<{
         web: z.ZodNumber;
         other: z.ZodNumber;
     }, z.core.$strict>;
+    authorityKindCounts: z.ZodObject<{
+        organization: z.ZodNumber;
+        workspace: z.ZodNumber;
+        personal: z.ZodNumber;
+    }, z.core.$strict>;
     topics: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         documentCount: z.ZodNumber;
@@ -314,6 +337,11 @@ export declare const WorkspaceStateKnowledge: z.ZodDiscriminatedUnion<[z.ZodObje
         web: z.ZodNumber;
         other: z.ZodNumber;
     }, z.core.$strict>;
+    authorityKindCounts: z.ZodObject<{
+        organization: z.ZodNumber;
+        workspace: z.ZodNumber;
+        personal: z.ZodNumber;
+    }, z.core.$strict>;
     topics: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         documentCount: z.ZodNumber;
@@ -646,6 +674,17 @@ export declare const WorkspaceStateResponse: z.ZodObject<{
             status: z.ZodLiteral<"not_implemented">;
         }, z.core.$strict>;
     }, z.core.$strict>;
+    preferences: z.ZodObject<{
+        authority: z.ZodLiteral<"preference_registry_preferences">;
+        activeDescriptorCount: z.ZodNumber;
+        activeDescriptorHash: z.ZodString;
+        scopeCounts: z.ZodObject<{
+            organization: z.ZodNumber;
+            workspace: z.ZodNumber;
+            user: z.ZodNumber;
+        }, z.core.$strict>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
     knowledge: z.ZodDiscriminatedUnion<[z.ZodObject<{
         availability: z.ZodLiteral<"available">;
         coverage: z.ZodEnum<{
@@ -683,6 +722,11 @@ export declare const WorkspaceStateResponse: z.ZodObject<{
             web: z.ZodNumber;
             other: z.ZodNumber;
         }, z.core.$strict>;
+        authorityKindCounts: z.ZodObject<{
+            organization: z.ZodNumber;
+            workspace: z.ZodNumber;
+            personal: z.ZodNumber;
+        }, z.core.$strict>;
         topics: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             documentCount: z.ZodNumber;
@@ -738,3 +782,302 @@ export declare const WorkspaceStateResponse: z.ZodObject<{
     }, z.core.$strict>], "availability">;
 }, z.core.$strict>;
 export type WorkspaceStateResponse = z.infer<typeof WorkspaceStateResponse>;
+export declare const WorkspaceStateExportOmission: z.ZodEnum<{
+    document_content_and_private_metadata: "document_content_and_private_metadata";
+    hidden_platform_prompts: "hidden_platform_prompts";
+    memory_content_and_provenance: "memory_content_and_provenance";
+    policy_bodies: "policy_bodies";
+    preference_content: "preference_content";
+    secret_values_and_credentials: "secret_values_and_credentials";
+    session_messages_and_tool_outputs: "session_messages_and_tool_outputs";
+}>;
+export type WorkspaceStateExportOmission = z.infer<typeof WorkspaceStateExportOmission>;
+export declare const WorkspaceStateExportResponse: z.ZodObject<{
+    kind: z.ZodLiteral<"opengeni.workspace_state.sanitized_export">;
+    schemaVersion: z.ZodLiteral<1>;
+    generatedAt: z.ZodString;
+    stateSha256: z.ZodString;
+    omissions: z.ZodArray<z.ZodEnum<{
+        document_content_and_private_metadata: "document_content_and_private_metadata";
+        hidden_platform_prompts: "hidden_platform_prompts";
+        memory_content_and_provenance: "memory_content_and_provenance";
+        policy_bodies: "policy_bodies";
+        preference_content: "preference_content";
+        secret_values_and_credentials: "secret_values_and_credentials";
+        session_messages_and_tool_outputs: "session_messages_and_tool_outputs";
+    }>>;
+    state: z.ZodObject<{
+        workspaceId: z.ZodString;
+        generatedAt: z.ZodString;
+        truth: z.ZodObject<{
+            current: z.ZodObject<{
+                source: z.ZodLiteral<"read_time_projection">;
+                capturedAt: z.ZodString;
+            }, 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">;
+            activeHeads: 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;
+            }, z.core.$strict>>;
+            activeHeadsTruncated: z.ZodBoolean;
+            latestRevision: z.ZodNullable<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;
+                provenanceSource: z.ZodEnum<{
+                    human: "human";
+                    knowledge_proposal: "knowledge_proposal";
+                    legacy_import: "legacy_import";
+                    onboarding: "onboarding";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    inactive: "inactive";
+                }>;
+                createdAt: z.ZodString;
+            }, z.core.$strict>>;
+            legacyRuntime: z.ZodObject<{
+                source: z.ZodEnum<{
+                    deployment_default: "deployment_default";
+                    workspace_override: "workspace_override";
+                }>;
+                workspaceOverrideConfigured: z.ZodBoolean;
+            }, z.core.$strict>;
+            runtimeComposition: z.ZodObject<{
+                status: z.ZodLiteral<"not_implemented">;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        preferences: z.ZodObject<{
+            authority: z.ZodLiteral<"preference_registry_preferences">;
+            activeDescriptorCount: z.ZodNumber;
+            activeDescriptorHash: z.ZodString;
+            scopeCounts: z.ZodObject<{
+                organization: z.ZodNumber;
+                workspace: z.ZodNumber;
+                user: z.ZodNumber;
+            }, z.core.$strict>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>;
+        knowledge: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            availability: z.ZodLiteral<"available">;
+            coverage: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+            }>;
+            baseCount: z.ZodNumber;
+            bases: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                visibleDocumentCount: z.ZodNumber;
+                statusCounts: z.ZodObject<{
+                    queued: z.ZodNumber;
+                    indexing: z.ZodNumber;
+                    ready: z.ZodNumber;
+                    failed: z.ZodNumber;
+                }, z.core.$strict>;
+                latestUpdatedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            basesTruncated: z.ZodBoolean;
+            inspectedVisibleDocumentCount: z.ZodNumber;
+            documentStatusCounts: z.ZodObject<{
+                queued: z.ZodNumber;
+                indexing: z.ZodNumber;
+                ready: z.ZodNumber;
+                failed: z.ZodNumber;
+            }, z.core.$strict>;
+            sourceKindCounts: z.ZodObject<{
+                manual_upload: z.ZodNumber;
+                meeting_transcript: z.ZodNumber;
+                repository: z.ZodNumber;
+                email: z.ZodNumber;
+                chat: z.ZodNumber;
+                document: z.ZodNumber;
+                web: z.ZodNumber;
+                other: z.ZodNumber;
+            }, z.core.$strict>;
+            authorityKindCounts: z.ZodObject<{
+                organization: z.ZodNumber;
+                workspace: z.ZodNumber;
+                personal: z.ZodNumber;
+            }, z.core.$strict>;
+            topics: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                documentCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            topicsTruncated: z.ZodBoolean;
+            latestDocumentUpdatedAt: z.ZodNullable<z.ZodString>;
+            memorySample: z.ZodObject<{
+                recordCount: z.ZodNumber;
+                sampleLimit: z.ZodLiteral<100>;
+                limitReached: z.ZodBoolean;
+                statusCounts: z.ZodObject<{
+                    proposed: z.ZodNumber;
+                    approved: z.ZodNumber;
+                    rejected: z.ZodNumber;
+                    active: z.ZodNumber;
+                    superseded: z.ZodNumber;
+                    archived: z.ZodNumber;
+                }, z.core.$strict>;
+                kindCounts: z.ZodObject<{
+                    semantic: z.ZodNumber;
+                    episodic: z.ZodNumber;
+                    procedural: z.ZodNumber;
+                    decision: z.ZodNumber;
+                    preference: z.ZodNumber;
+                }, z.core.$strict>;
+                preferenceAuthority: z.ZodObject<{
+                    kindCountSource: z.ZodLiteral<"knowledge_memories_legacy_observations">;
+                    activeAuthority: z.ZodLiteral<"structured_preference_registry">;
+                }, z.core.$strict>;
+                latestUpdatedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            gaps: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    failed_documents: "failed_documents";
+                    missing_topic_coverage: "missing_topic_coverage";
+                    no_document_bases: "no_document_bases";
+                    no_memory_records: "no_memory_records";
+                    no_visible_documents: "no_visible_documents";
+                    partial_inventory: "partial_inventory";
+                    pending_memory_review: "pending_memory_review";
+                    processing_documents: "processing_documents";
+                }>;
+                severity: z.ZodEnum<{
+                    info: "info";
+                    warning: "warning";
+                }>;
+                relatedCount: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            availability: z.ZodLiteral<"unavailable">;
+            reason: z.ZodLiteral<"missing_permission">;
+            requiredPermission: z.ZodLiteral<"documents:search">;
+        }, z.core.$strict>], "availability">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WorkspaceStateExportResponse = z.infer<typeof WorkspaceStateExportResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.36.0",
+  "version": "0.38.1",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,6 +29,10 @@
     "./google-drive": {
       "types": "./dist/google-drive.d.ts",
       "import": "./dist/google-drive.js"
+    },
+    "./connector-destinations": {
+      "types": "./dist/connector-destinations.d.ts",
+      "import": "./dist/connector-destinations.js"
     }
   },
   "publishConfig": {

package/src/connector-destinations.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+
+export const ConnectorDocumentDestinationAuthority = z.enum([
+  "organization",
+  "workspace",
+  "personal",
+]);
+export type ConnectorDocumentDestinationAuthority = z.infer<
+  typeof ConnectorDocumentDestinationAuthority
+>;
+
+export const ConnectorDocumentDestinationSelection = z.object({
+  authorityKind: ConnectorDocumentDestinationAuthority,
+  collectionId: z.string().uuid().nullable().default(null),
+});
+export type ConnectorDocumentDestinationSelection = z.infer<
+  typeof ConnectorDocumentDestinationSelection
+>;
+
+export const ConnectorDocumentDestination = z
+  .object({
+    authorityKind: ConnectorDocumentDestinationAuthority,
+    authorityAccountId: z.string().uuid(),
+    authorityWorkspaceId: z.string().uuid().nullable(),
+    authoritySubjectId: z.string().trim().min(1).max(1024).nullable(),
+    collectionId: z.string().uuid().nullable().default(null),
+  })
+  .superRefine((destination, context) => {
+    if (destination.authorityKind === "organization") {
+      if (destination.authorityWorkspaceId !== null || destination.authoritySubjectId !== null) {
+        context.addIssue({
+          code: "custom",
+          message: "organization connector destinations cannot bind workspace or subject authority",
+        });
+      }
+      return;
+    }
+    if (destination.authorityWorkspaceId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace and personal connector destinations require workspace authority",
+      });
+    }
+    if (destination.authorityKind === "workspace" && destination.authoritySubjectId !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace connector destinations cannot bind subject authority",
+      });
+    }
+    if (destination.authorityKind === "personal" && destination.authoritySubjectId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "personal connector destinations require immutable subject authority",
+      });
+    }
+  });
+export type ConnectorDocumentDestination = z.infer<typeof ConnectorDocumentDestination>;
+
+export function bindConnectorDocumentDestination(
+  selection: ConnectorDocumentDestinationSelection,
+  context: { accountId: string; workspaceId: string; initiatingSubjectId: string },
+): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: selection.authorityKind,
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: selection.authorityKind === "organization" ? null : context.workspaceId,
+    authoritySubjectId: selection.authorityKind === "personal" ? context.initiatingSubjectId : null,
+    collectionId: selection.collectionId,
+  });
+}
+
+export function legacyWorkspaceConnectorDocumentDestination(context: {
+  accountId: string;
+  workspaceId: string;
+}): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: "workspace",
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: context.workspaceId,
+    authoritySubjectId: null,
+    collectionId: null,
+  });
+}
+
+export function resolveConnectorDocumentDestination(
+  value: unknown,
+  context: {
+    accountId: string;
+    workspaceId: string;
+    connectionSubjectId?: string | null | undefined;
+  },
+): ConnectorDocumentDestination {
+  if (value === undefined || value === null) {
+    return legacyWorkspaceConnectorDocumentDestination(context);
+  }
+  const destination = ConnectorDocumentDestination.parse(value);
+  if (destination.authorityAccountId !== context.accountId) {
+    throw new Error("connector destination organization authority mismatch");
+  }
+  if (
+    destination.authorityKind !== "organization" &&
+    destination.authorityWorkspaceId !== context.workspaceId
+  ) {
+    throw new Error("connector destination workspace authority mismatch");
+  }
+  if (
+    destination.authorityKind === "personal" &&
+    destination.authoritySubjectId !== context.connectionSubjectId
+  ) {
+    throw new Error("connector destination personal authority mismatch");
+  }
+  return destination;
+}
+
+export function connectorDestinationDocumentAuthority(destination: ConnectorDocumentDestination): {
+  authorityKind: ConnectorDocumentDestinationAuthority;
+  authorityWorkspaceId: string | null;
+  authoritySubjectId: string | null;
+} {
+  return {
+    authorityKind: destination.authorityKind,
+    authorityWorkspaceId: destination.authorityWorkspaceId,
+    authoritySubjectId: destination.authoritySubjectId,
+  };
+}
+
+export function connectorDocumentDestinationCollectionId(
+  destination: ConnectorDocumentDestination,
+  defaultCollectionId: string,
+): string {
+  return destination.collectionId ?? z.string().uuid().parse(defaultCollectionId);
+}

package/src/google-drive.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 
 import { ConnectionMetadata } from "./index";
+import {
+  ConnectorDocumentDestination,
+  ConnectorDocumentDestinationSelection,
+} from "./connector-destinations";
 
 export const GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com" as const;
 export const GOOGLE_DRIVE_FULL_SCOPE = "https://www.googleapis.com/auth/drive" as const;
@@ -63,6 +67,7 @@ export function googleDriveScopesAllowCapability(
   return googleDriveOAuthScopeDecision(grantedScopes).capabilities.includes(capability);
 }
 
+/** @deprecated Connector document destinations use organization/workspace/personal authority. */
 export const GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
 export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
 
@@ -130,7 +135,9 @@ export const GoogleDriveSelectedSource = z.object({
   name: z.string().min(1).max(1024),
   mimeType: z.string().min(1).max(256),
   driveId: z.string().min(1).max(256).nullable().default(null),
-  targetScope: GoogleDriveTargetScope,
+  destination: ConnectorDocumentDestination.optional(),
+  /** @deprecated Missing destinations resolve to the current workspace boundary. */
+  targetScope: GoogleDriveTargetScope.optional(),
   syncCadence: GoogleDriveSyncCadence.default("hourly"),
   readPolicy: GoogleDriveReadPolicy.default("allow"),
   selectedAt: z.string().datetime({ offset: true }),
@@ -147,6 +154,7 @@ export const GoogleDriveConnectionMetadata = z
     verifiedAt: z.string().datetime({ offset: true }),
     accessMode: z.enum(["metadata_readonly", "readonly"]),
     lifecycle: GoogleDriveConnectionLifecycle.optional(),
+    documentDestination: ConnectorDocumentDestination.optional(),
     selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
     /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
     selectedSource: GoogleDriveSelectedSource.nullable().optional(),
@@ -199,22 +207,28 @@ export const GoogleDriveBrowseResponse = z.object({
 });
 export type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;
 
-export const SaveGoogleDriveSourceRequest = z.object({
-  sources: z
-    .array(
-      GoogleDriveBrowseItem.pick({
-        id: true,
-        name: true,
-        mimeType: true,
-        driveId: true,
+export const SaveGoogleDriveSourceRequest = z
+  .object({
+    sources: z
+      .array(
+        GoogleDriveBrowseItem.pick({
+          id: true,
+          name: true,
+          mimeType: true,
+          driveId: true,
+        }),
+      )
+      .max(100)
+      .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
+        message: "Google Drive sources must be unique",
       }),
-    )
-    .max(100)
-    .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
-      message: "Google Drive sources must be unique",
-    }),
-  targetScope: GoogleDriveTargetScope,
-  syncCadence: GoogleDriveSyncCadence.default("hourly"),
-  readPolicy: GoogleDriveReadPolicy.default("allow"),
-});
+    destination: ConnectorDocumentDestinationSelection.optional(),
+    /** @deprecated Legacy requests are accepted but resolve to workspace authority. */
+    targetScope: GoogleDriveTargetScope.optional(),
+    syncCadence: GoogleDriveSyncCadence.default("hourly"),
+    readPolicy: GoogleDriveReadPolicy.default("allow"),
+  })
+  .refine((request) => request.destination !== undefined || request.targetScope !== undefined, {
+    message: "Google Drive document destination is required",
+  });
 export type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;

package/src/index.ts

@@ -8,6 +8,7 @@ import {
 import { WorkspaceInstructionPolicyRoleKeyInput } from "./workspace-instruction-policies";
 
 export * from "./slack-bot-scopes";
+export * from "./connector-destinations";
 
 export {
   CreateWorkspaceArtifactRequest,
@@ -1149,7 +1150,11 @@ export const ClientVoiceInputConfig = z
   .object({
     available: z.boolean(),
     maxDurationSeconds: z.number().int().positive().max(600),
-    maxSizeBytes: z.number().int().positive(),
+    maxSizeBytes: z
+      .number()
+      .int()
+      .positive()
+      .max(25 * 1024 * 1024),
     acceptedMimeTypes: z.array(z.string().trim().min(1).max(128)).min(1).max(32),
   })
   .strict();
@@ -1164,7 +1169,7 @@ export const TranscribeAudioResponse = z
   .strict();
 export type TranscribeAudioResponse = z.infer<typeof TranscribeAudioResponse>;
 
-/** Default ceilings for native voice input (hard-stop recording + upload). */
+/** Default safety ceiling for one-shot native voice input (60 seconds). */
 export const VOICE_INPUT_MAX_DURATION_SECONDS = 60 as const;
 export const VOICE_INPUT_MAX_SIZE_BYTES = 25 * 1024 * 1024;
 export const VOICE_INPUT_ACCEPTED_MIME_TYPES = [
@@ -6205,6 +6210,9 @@ export const Session = z.object({
   // stale in-flight op and retry against the new active sandbox.
   activeSandboxId: z.string().uuid().nullable(),
   activeEpoch: z.number().int().nonnegative(),
+  // The explicit connected-machine project root selected for this session.
+  // Null means the enrolled agent's launch workspace root.
+  workingDir: z.string().nullable().default(null),
   variableSetId: z.string().uuid().nullable().default(null),
   /** @deprecated use variableSetId */
   environmentId: z.string().uuid().nullable().default(null),
@@ -9768,6 +9776,8 @@ export const ClientModel = /* @__PURE__ */ defineModelContractSchema(() =>
   z.object({
     id: z.string(),
     label: z.string(),
+    /** Optional curated compact label for dense UI (e.g. mobile composer). */
+    shortLabel: z.string().min(1).max(64).optional(),
     provider: z.string(), // provider id
     providerLabel: z.string(),
     api: z.enum(["responses", "chat"]),