@opengeni/db 0.28.9 → 0.36.0

package/dist/workspace-learning-policy.d.ts

@@ -0,0 +1,161 @@
+import { WorkspaceLearningPolicySnapshot, type WorkspaceLearningPolicyActivationEvent, type WorkspaceLearningPolicyActivationType, type WorkspaceLearningPolicyHead, type WorkspaceLearningPolicyRevision, type WorkspaceLearningSourceOverrideInput } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+export declare class WorkspaceLearningPolicyConflictError extends Error {
+    readonly currentHead: WorkspaceLearningPolicyHead | null;
+    readonly name = "WorkspaceLearningPolicyConflictError";
+    readonly code = "WORKSPACE_LEARNING_POLICY_CONFLICT";
+    constructor(currentHead: WorkspaceLearningPolicyHead | null);
+}
+export declare class WorkspaceLearningPolicyOperationReuseError extends Error {
+    readonly name = "WorkspaceLearningPolicyOperationReuseError";
+    readonly code = "WORKSPACE_LEARNING_POLICY_OPERATION_REUSED";
+    constructor();
+}
+export declare class WorkspaceLearningPolicyNotFoundError extends Error {
+    readonly name = "WorkspaceLearningPolicyNotFoundError";
+    constructor(message?: string);
+}
+export declare class WorkspaceLearningPolicyInvalidOperationError extends Error {
+    readonly name = "WorkspaceLearningPolicyInvalidOperationError";
+}
+export declare class WorkspaceLearningPolicyAuthorityError extends Error {
+    readonly name = "WorkspaceLearningPolicyAuthorityError";
+}
+export type WorkspaceLearningPolicyAttemptClaims = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+};
+export declare function createWorkspaceLearningPolicyRevision(db: Database, input: {
+    operationId?: string;
+    accountId: string;
+    workspaceId: string;
+    workspaceMode: "off" | "suggest" | "automatic";
+    sourceOverrides?: WorkspaceLearningSourceOverrideInput[];
+    supersedesRevisionId?: string | null;
+    actorSubjectId: string;
+    principalKind: string | undefined;
+}): Promise<WorkspaceLearningPolicyRevision>;
+declare function changeActiveWorkspaceLearningPolicy(db: Database, input: {
+    operationId?: string;
+    accountId: string;
+    workspaceId: string;
+    targetRevisionId: string;
+    expectedCurrentRevisionId: string | null;
+    expectedActivationVersion: number;
+    actorSubjectId: string;
+    principalKind: string | undefined;
+    reason: string;
+    type: WorkspaceLearningPolicyActivationType;
+}): Promise<{
+    head: {
+        accountId: string;
+        workspaceId: string;
+        revisionId: string;
+        revision: number;
+        policyHash: string;
+        activationVersion: number;
+        activatedAt: string;
+    };
+    event: {
+        id: string;
+        operationId: string;
+        accountId: string;
+        workspaceId: string;
+        type: "activate" | "rollback";
+        activationVersion: number;
+        oldRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        } | null;
+        newRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        };
+        actorSubjectId: string;
+        reason: string;
+        createdAt: string;
+    };
+}>;
+export declare function activateWorkspaceLearningPolicyRevision(db: Database, input: Omit<Parameters<typeof changeActiveWorkspaceLearningPolicy>[1], "type" | "targetRevisionId"> & {
+    revisionId: string;
+}): Promise<{
+    head: {
+        accountId: string;
+        workspaceId: string;
+        revisionId: string;
+        revision: number;
+        policyHash: string;
+        activationVersion: number;
+        activatedAt: string;
+    };
+    event: {
+        id: string;
+        operationId: string;
+        accountId: string;
+        workspaceId: string;
+        type: "activate" | "rollback";
+        activationVersion: number;
+        oldRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        } | null;
+        newRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        };
+        actorSubjectId: string;
+        reason: string;
+        createdAt: string;
+    };
+}>;
+export declare function rollbackWorkspaceLearningPolicyRevision(db: Database, input: Omit<Parameters<typeof changeActiveWorkspaceLearningPolicy>[1], "type">): Promise<{
+    head: {
+        accountId: string;
+        workspaceId: string;
+        revisionId: string;
+        revision: number;
+        policyHash: string;
+        activationVersion: number;
+        activatedAt: string;
+    };
+    event: {
+        id: string;
+        operationId: string;
+        accountId: string;
+        workspaceId: string;
+        type: "activate" | "rollback";
+        activationVersion: number;
+        oldRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        } | null;
+        newRevision: {
+            id: string;
+            revision: number;
+            policyHash: string;
+        };
+        actorSubjectId: string;
+        reason: string;
+        createdAt: string;
+    };
+}>;
+export declare function listWorkspaceLearningPolicyHistory(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    limit?: number;
+}): Promise<{
+    head: WorkspaceLearningPolicyHead | null;
+    revisions: WorkspaceLearningPolicyRevision[];
+    events: WorkspaceLearningPolicyActivationEvent[];
+}>;
+export declare function getOrCreateWorkspaceLearningPolicySnapshot(db: Database, claims: WorkspaceLearningPolicyAttemptClaims): Promise<WorkspaceLearningPolicySnapshot>;
+export {};

package/dist/xai-subscription.d.ts

@@ -0,0 +1,326 @@
+import { type XaiProviderAccountAuthoritySnapshotV1 as XaiAuthoritySnapshot } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+import * as schema from "./schema.js";
+export type XaiAccountAuthorityScope = "workspace" | "user";
+export type XaiCredentialStatus = "active" | "needs_relogin" | "error" | "disabled";
+export type XaiCredentialSecretV1 = {
+    version: 1;
+    accessToken?: string;
+    refreshToken?: string;
+    sessionToken?: string;
+    cookie?: string;
+};
+export type XaiSubscriptionAccountMetadata = {
+    id: string;
+    scope: XaiAccountAuthorityScope;
+    providerAccountId: string | null;
+    label: string | null;
+    accountEmail: string | null;
+    planType: string | null;
+    status: XaiCredentialStatus;
+    allocatorEnabled: boolean;
+    version: number;
+    allocatorVersion: number;
+    allocatorUpdatedAt: Date | null;
+    expiresAt: Date | null;
+    lastRefreshAt: Date | null;
+    lastError: string | null;
+    quotaUsedPercent: number | null;
+    quotaResetAt: Date | null;
+    quotaCheckedAt: Date | null;
+    exhaustedUntil: Date | null;
+    selectionCount: number;
+    lastSelectedAt: Date | null;
+    connectedBySubjectId: string | null;
+};
+export type XaiCredentialForRun = XaiSubscriptionAccountMetadata & {
+    secret: XaiCredentialSecretV1;
+    authoritySnapshot: XaiAuthoritySnapshot;
+};
+export type XaiCredentialLeaseResult = {
+    credentialId: string | null;
+    rotationEnabled: boolean;
+    reused: boolean;
+    holderId: string | null;
+    generation: number | null;
+    leasedUntil: Date | null;
+    accounts: XaiSubscriptionAccountMetadata[];
+};
+export declare const XAI_CREDENTIAL_LEASE_TTL_MS: number;
+/** Stable session sharding, matching Codex's cache-affinity contract. */
+export declare function xaiCredentialShardIndex(sessionId: string, candidateCount: number): number;
+export declare function createXaiSubscriptionCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    scope?: XaiAccountAuthorityScope;
+    encryptionKey: Uint8Array;
+    secret: XaiCredentialSecretV1;
+    providerAccountId?: string | null;
+    label?: string | null;
+    accountEmail?: string | null;
+    planType?: string | null;
+    expiresAt?: Date | null;
+}): Promise<{
+    account: XaiSubscriptionAccountMetadata;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}>;
+export declare function upsertXaiSubscriptionCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    credentialId?: string | null;
+    authoritySnapshot?: XaiAuthoritySnapshot;
+    scope?: XaiAccountAuthorityScope;
+    encryptionKey: Uint8Array;
+    secret: XaiCredentialSecretV1;
+    providerAccountId?: string | null;
+    label?: string | null;
+    accountEmail?: string | null;
+    planType?: string | null;
+    expiresAt?: Date | null;
+}): Promise<{
+    account: XaiSubscriptionAccountMetadata;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}>;
+export declare function listXaiSubscriptionAccountsMetadata(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+}): Promise<XaiSubscriptionAccountMetadata[]>;
+/**
+ * Metadata-only readiness check for the SuperGrok model catalog.
+ *
+ * Like Codex, allocator eligibility is runtime scheduling state, not connection
+ * readiness. With rotation enabled any healthy account makes the rail ready;
+ * with rotation disabled the explicit active account is authoritative.
+ */
+export declare function workspaceXaiSubscriptionActive(db: Database, settings: {
+    readonly supergrokSubscriptionEnabled: boolean;
+}, workspaceId: string, subjectId: string): Promise<boolean>;
+export declare function getXaiSubscriptionAccountMetadata(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+}): Promise<XaiSubscriptionAccountMetadata | null>;
+export declare function getXaiSubscriptionAccountAuthoritySnapshot(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+}): Promise<XaiAuthoritySnapshot | null>;
+/**
+ * Resolve the provider-account authority frozen on a newly accepted human turn.
+ * Workspace authority is the default. A caller's private pool becomes effective
+ * only after that exact pool has an active credential pointer, which is set by
+ * the caller's explicit private connection/activation action.
+ */
+export declare function resolveXaiProviderAccountAuthoritySnapshotForAcceptance(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+}): Promise<XaiAuthoritySnapshot>;
+/** Transaction-local acceptance resolver. The caller must already have set the
+ * exact authenticated subject GUC on this same transaction. */
+export declare function resolveXaiProviderAccountAuthoritySnapshotForAcceptanceInTransaction(db: Database, input: {
+    workspaceId: string;
+}): Promise<XaiAuthoritySnapshot>;
+export declare function updateXaiSubscriptionAccountSettings(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    expectedVersion: number;
+    label?: string | null;
+    allocatorEnabled?: boolean;
+}): Promise<XaiSubscriptionAccountMetadata>;
+export type XaiAllocatorUpdateResult = {
+    kind: "updated" | "unchanged" | "conflict";
+    allocatorEnabled: boolean;
+    allocatorVersion: number;
+    allocatorUpdatedAt: Date | null;
+} | {
+    kind: "not_found";
+};
+export declare function updateXaiAllocatorEligibility(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    enabled: boolean;
+    expectedVersion: number;
+}): Promise<XaiAllocatorUpdateResult>;
+export declare function renameXaiSubscriptionAccount(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    label: string | null;
+}): Promise<XaiSubscriptionAccountMetadata | null>;
+export declare function disconnectXaiSubscriptionCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}): Promise<boolean>;
+export declare function materializeXaiCredentialForRun(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    encryptionKey: Uint8Array;
+}): Promise<XaiCredentialForRun>;
+export type XaiSerializedCredentialRefreshResult = {
+    credential: XaiCredentialForRun;
+    refreshed: boolean;
+};
+/**
+ * Refresh one connected xAI account under a database row lock.
+ *
+ * OAuth refresh tokens may rotate. Multiple sessions are allowed to share the
+ * same account, so an unlocked read-refresh-write sequence can make one
+ * successful refresh invalidate every other in-flight refresh. This operation
+ * re-reads the secret after acquiring the lock and skips the provider call when
+ * another request already installed a newer token pair.
+ */
+export declare function refreshXaiSubscriptionCredentialSerialized(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    encryptionKey: Uint8Array;
+    observedAccessToken: string | undefined;
+    observedRefreshToken: string | undefined;
+    refresh: (current: XaiCredentialForRun) => Promise<{
+        secret: XaiCredentialSecretV1;
+        expiresAt: Date | null;
+    }>;
+}): Promise<XaiSerializedCredentialRefreshResult>;
+export declare function acquireXaiCredentialLease(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    sessionId: string;
+    turnId: string;
+    holderId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    pinnedCredentialId?: string | null;
+    pinSource?: "manual" | "policy" | null;
+    now?: Date;
+    leaseTtlMs?: number;
+}): Promise<XaiCredentialLeaseResult>;
+/**
+ * Select an authorized connected account for a non-turn operation (voice,
+ * transcription, media). Rotation uses the same stable session/request shard
+ * as turns, but does not create a capacity lease: one account may serve many
+ * concurrent upstream sessions just like Codex subscriptions.
+ */
+export declare function selectXaiCredentialForUse(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    shardKey: string;
+    pinnedCredentialId?: string | null;
+    pinSource?: "manual" | "policy" | null;
+    now?: Date;
+}): Promise<{
+    credentialId: string | null;
+    rotationEnabled: boolean;
+    accounts: XaiSubscriptionAccountMetadata[];
+}>;
+export declare function releaseXaiCredentialLease(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    turnId: string;
+    holderId: string;
+    generation: number;
+}): Promise<boolean>;
+export declare function heartbeatXaiCredentialLeaseUntil(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    turnId: string;
+    holderId: string;
+    generation: number;
+    leaseTtlMs?: number;
+    now?: Date;
+}): Promise<Date | null>;
+export declare function getXaiRotationSettings(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}): Promise<typeof schema.xaiRotationSettings.$inferSelect | null>;
+export declare function ensureXaiRotationSettings(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}): Promise<typeof schema.xaiRotationSettings.$inferSelect>;
+export declare function setActiveXaiCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    credentialId: string;
+}): Promise<boolean>;
+export declare function setInitialActiveXaiCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    credentialId: string;
+}): Promise<boolean>;
+export declare function disconnectXaiSubscriptionCredentialAndRepick(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}): Promise<{
+    disconnected: boolean;
+    newActiveCredentialId: string | null;
+}>;
+export declare function updateXaiRotationSettings(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    expectedVersion: number;
+    rotationEnabled: boolean;
+}): Promise<typeof schema.xaiRotationSettings.$inferSelect>;
+export declare function setXaiSessionAccountPin(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    sessionId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    credentialId: string | null;
+    pinSource: "manual" | "policy" | null;
+    /** undefined = unconditional human write; null = row must not exist. */
+    expectedVersion?: number | null;
+}): Promise<typeof schema.xaiSessionAccountPins.$inferSelect>;
+export declare function getXaiSessionAccountPin(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    sessionId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+}): Promise<typeof schema.xaiSessionAccountPins.$inferSelect | null>;
+export declare function recordXaiSessionLastAccount(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    sessionId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    credentialId: string;
+}): Promise<typeof schema.xaiSessionAccountPins.$inferSelect>;
+export declare function updateXaiQuotaMetadata(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    credentialId: string;
+    quotaUsedPercent: number | null;
+    quotaResetAt: Date | null;
+    quotaCheckedAt: Date;
+    exhaustedUntil: Date | null;
+}): Promise<boolean>;
+export declare function wakeXaiCapacityWaiters(db: Database, input: {
+    workspaceId: string;
+    subjectId: string;
+    authoritySnapshot: XaiAuthoritySnapshot;
+    reason: string;
+    now?: Date;
+}): Promise<number>;

package/drizzle/0183_model_call_provider_cost_estimates.sql

@@ -0,0 +1,39 @@
+-- deployment-mode: rolling
+-- Preserve the captured provider-rate comparison separately from the OpenGeni
+-- credit price. Existing facts remain unknown rather than being rewritten with
+-- today's rates or incorrectly treating credit markup as provider cost.
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '5min';
+
+ALTER TABLE "model_call_facts"
+  ADD COLUMN IF NOT EXISTS "estimated_provider_cost_micros" bigint,
+  ADD COLUMN IF NOT EXISTS "pricing_source" text;
+
+ALTER TABLE "model_call_facts"
+  DROP CONSTRAINT IF EXISTS "model_call_facts_estimated_provider_cost_check",
+  ADD CONSTRAINT "model_call_facts_estimated_provider_cost_check"
+    CHECK (
+      "estimated_provider_cost_micros" IS NULL
+      OR "estimated_provider_cost_micros" >= 0
+    ) NOT VALID;
+
+ALTER TABLE "model_call_facts"
+  VALIDATE CONSTRAINT "model_call_facts_estimated_provider_cost_check";
+
+ALTER TABLE "model_call_facts"
+  DROP CONSTRAINT IF EXISTS "model_call_facts_pricing_source_check",
+  ADD CONSTRAINT "model_call_facts_pricing_source_check"
+    CHECK (
+      ("estimated_provider_cost_micros" IS NULL AND "pricing_source" IS NULL)
+      OR (
+        "estimated_provider_cost_micros" IS NOT NULL
+        AND "pricing_source" IN ('configured_list_price', 'gateway_reported')
+      )
+    ) NOT VALID;
+
+ALTER TABLE "model_call_facts"
+  VALIDATE CONSTRAINT "model_call_facts_pricing_source_check";
+
+RESET statement_timeout;
+RESET lock_timeout;