@opengeni/db 0.28.9 → 0.36.0

package/dist/task-notes.d.ts

@@ -0,0 +1,85 @@
+import { type TaskNoteKind as TaskNoteKindType } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+export type TaskNoteAttemptClaims = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+};
+export type CreateTaskNoteInput = TaskNoteAttemptClaims & {
+    operationId: string;
+    kind: TaskNoteKindType;
+    text: string;
+    expiresInDays: number;
+};
+export type ArchiveTaskNoteInput = TaskNoteAttemptClaims & {
+    operationId: string;
+    noteId: string;
+    expectedVersion: number;
+    reason: string;
+};
+export type ListTaskNotesInput = TaskNoteAttemptClaims & {
+    includeArchived?: boolean;
+    limit?: number;
+};
+export declare function createTaskNote(db: Database, input: CreateTaskNoteInput): Promise<{
+    note: {
+        id: string;
+        rootSessionId: string;
+        kind: "artifact" | "blocker" | "decision" | "finding" | "handoff" | "ownership";
+        text: string;
+        status: "active" | "archived";
+        version: number;
+        expiresAt: string;
+        createdAt: string;
+        updatedAt: string;
+        archivedAt: string | null;
+        provenance: {
+            actorKind: "human" | "service";
+            sourceSessionId: string;
+            sourceTurnId: string;
+        };
+    };
+    replayed: boolean;
+}>;
+export declare function archiveTaskNote(db: Database, input: ArchiveTaskNoteInput): Promise<{
+    note: {
+        id: string;
+        rootSessionId: string;
+        kind: "artifact" | "blocker" | "decision" | "finding" | "handoff" | "ownership";
+        text: string;
+        status: "active" | "archived";
+        version: number;
+        expiresAt: string;
+        createdAt: string;
+        updatedAt: string;
+        archivedAt: string | null;
+        provenance: {
+            actorKind: "human" | "service";
+            sourceSessionId: string;
+            sourceTurnId: string;
+        };
+    };
+    replayed: boolean;
+}>;
+export declare function listTaskNotes(db: Database, input: ListTaskNotesInput): Promise<{
+    notes: {
+        id: string;
+        rootSessionId: string;
+        kind: "artifact" | "blocker" | "decision" | "finding" | "handoff" | "ownership";
+        text: string;
+        status: "active" | "archived";
+        version: number;
+        expiresAt: string;
+        createdAt: string;
+        updatedAt: string;
+        archivedAt: string | null;
+        provenance: {
+            actorKind: "human" | "service";
+            sourceSessionId: string;
+            sourceTurnId: string;
+        };
+    }[];
+}>;

package/dist/transcription-recordings.d.ts

@@ -1,6 +1,6 @@
 import type { TranscriptionRecording, TranscriptionRecordingErrorCode, TranscriptionRecordingResponse } from "@opengeni/contracts";
-import type { Database } from "./database";
-import * as schema from "./schema";
+import type { Database } from "./database.js";
+import * as schema from "./schema.js";
 type ChunkRow = typeof schema.transcriptionRecordingChunks.$inferSelect;
 type SegmentRow = typeof schema.transcriptionRecordingSegments.$inferSelect;
 export declare class TranscriptionRecordingNotFoundError extends Error {

package/dist/turn-initiator.d.ts

@@ -1,6 +1,6 @@
 import { type TurnInitiator, type TurnInitiatorContext } from "@opengeni/contracts";
-import type { Database } from "./database";
-import type { SessionCommandActor } from "./session-control";
+import type { Database } from "./database.js";
+import type { SessionCommandActor } from "./session-control.js";
 export declare const UNATTRIBUTED_LEGACY_INITIATOR: TurnInitiator;
 export type FrozenTurnInitiator = {
     initiator: TurnInitiator;

package/dist/video-generation.d.ts

@@ -0,0 +1,225 @@
+import { type GeneratedVideoFacts, type MediaGenerationResult, type VideoGenerationFundingSource, type VideoGenerationPolicy as VideoGenerationPolicyValue } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+import * as schema from "./schema.js";
+export declare const ACTIVE_VIDEO_GENERATION_STATUSES: readonly ["preparing", "prepared", "accepted", "submission_uncertain", "provider_started", "retaining"];
+export type VideoGenerationOperation = typeof schema.videoGenerationOperations.$inferSelect;
+export type VideoGenerationReference = typeof schema.videoGenerationReferences.$inferSelect;
+export type GeneratedVideoArtifact = typeof schema.generatedVideoArtifacts.$inferSelect;
+export type VideoGenerationOperationWithReferences = VideoGenerationOperation & {
+    references: VideoGenerationReference[];
+};
+export declare class VideoGenerationConflictError extends Error {
+    constructor(message: string);
+}
+export declare class VideoGenerationCapacityError extends Error {
+    constructor(message: string);
+}
+export declare class VideoGenerationCreditError extends Error {
+    constructor(message?: string);
+}
+export declare function getWorkspaceVideoGenerationPolicy(db: Database, workspaceId: string): Promise<VideoGenerationPolicyValue>;
+export declare function updateWorkspaceVideoGenerationPolicy(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    expectedRevision: number;
+    fundingSource: VideoGenerationFundingSource;
+    enabledModelIds: string[];
+    defaultModelId: string | null;
+}): Promise<VideoGenerationPolicyValue>;
+export type AdmitVideoGenerationOperationInput = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    toolCallId: string;
+    admissionKey: string;
+    requestDigest: string;
+    promptDigest: string;
+    requestEncrypted: string;
+    modelId: string;
+    sourceMode: string;
+    capabilityRevision: string;
+    policyRevision: number;
+    fundingSource: VideoGenerationFundingSource;
+    pricedCostMicros: number;
+    connectionId: string | null;
+    credentialVersion: number;
+    credentialEncrypted: string;
+    providerIdempotencyKey: string;
+    expectedArtifactId: string;
+    expectedFileId: string;
+    reservedBytes?: number;
+    workspaceQuotaBytes: number;
+    maxConcurrentPerWorkspace: number;
+    recoveryDeadlineAt: Date;
+    references: Array<{
+        ordinal: number;
+        role: string;
+        contentType: string;
+        sizeBytes: number;
+        sha256: string;
+        stagingObjectKey: string;
+        grantExpiresAt?: Date | null;
+        cleanupAfter: Date;
+    }>;
+};
+export declare function admitVideoGenerationOperation(db: Database, input: AdmitVideoGenerationOperationInput): Promise<{
+    operation: VideoGenerationOperation;
+    created: boolean;
+}>;
+/** Persist a rotated provider token before it is used for another remote call. */
+export declare function rotateVideoGenerationCredential(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    requestDigest: string;
+    expectedCredentialEncrypted: string;
+    credentialEncrypted: string;
+}): Promise<VideoGenerationOperation>;
+/**
+ * Seal a reference-bearing operation only after every immutable staging object
+ * has been uploaded and independently verified by the worker.  The source
+ * sandbox path is intentionally not stored, so a failed preparation can only
+ * be retried by the same logical tool call while its sandbox still exists.
+ */
+export declare function markVideoGenerationPrepared(db: Database, input: OperationMutationInput): Promise<VideoGenerationOperation>;
+/** Final authorization fence. Call only after the accepted function output is durable. */
+export declare function markVideoGenerationAccepted(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    requestDigest: string;
+}): Promise<VideoGenerationOperation>;
+/**
+ * Transactional half of acceptance.  The pending function result and this
+ * transition must commit together: the provider reconciler never observes an
+ * accepted operation whose model-visible `accepted` receipt was lost.
+ */
+export declare function markVideoGenerationAcceptedInTransaction(tx: Database, input: {
+    workspaceId: string;
+    operation: VideoGenerationOperation;
+    toolCallId?: string;
+}): Promise<VideoGenerationOperation>;
+export declare function cancelVideoGenerationBeforeSubmit(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    requestDigest: string;
+    reason: string;
+}): Promise<VideoGenerationOperation>;
+/**
+ * Turn-interruption half of pre-submit cancellation. It runs under the same
+ * session/turn transaction that closes unresolved tool calls, so an accepted
+ * receipt can never race a cancellation of its operation.
+ */
+export declare function cancelUnacceptedVideoGenerationsForToolCallsInTransaction(tx: Database, input: {
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    toolCallIds: readonly string[];
+    reason: string;
+    now: Date;
+}): Promise<string[]>;
+export declare function claimVideoGenerationOperations(db: Database, input: {
+    owner: string;
+    leaseSeconds: number;
+    limit: number;
+}): Promise<Array<{
+    operationId: string;
+    accountId: string;
+    workspaceId: string;
+}>>;
+export declare function getVideoGenerationOperation(db: Database, workspaceId: string, operationId: string): Promise<VideoGenerationOperationWithReferences | null>;
+export declare function markVideoGenerationSubmissionUncertain(db: Database, input: OperationMutationInput & {
+    nextReconcileAt: Date;
+    error: string;
+}): Promise<VideoGenerationOperation>;
+/**
+ * Freeze the exact provider start body before issuing the request. If the
+ * worker disappears after this transaction, recovery replays the same body
+ * and idempotency key rather than reminting URLs or changing request bytes.
+ */
+export declare function markVideoGenerationSubmissionIntent(db: Database, input: OperationMutationInput & {
+    encryptedProviderRequest: string;
+    providerRequestExpiresAt: Date;
+    nextReconcileAt: Date;
+}): Promise<VideoGenerationOperation>;
+export declare function markVideoGenerationProviderStarted(db: Database, input: OperationMutationInput & {
+    providerJobId: string;
+    nextReconcileAt: Date;
+}): Promise<VideoGenerationOperation>;
+export declare function rescheduleVideoGenerationOperation(db: Database, input: OperationMutationInput & {
+    owner?: string;
+    nextReconcileAt: Date;
+    error?: string;
+}): Promise<boolean>;
+export declare function markVideoGenerationRetaining(db: Database, input: OperationMutationInput): Promise<VideoGenerationOperation>;
+export declare function settleVideoGenerationFailure(db: Database, input: OperationMutationInput & {
+    status: "provider_failed" | "retention_failed" | "outcome_unknown";
+    publicReason: string;
+    privateError?: string;
+}): Promise<VideoGenerationOperation>;
+export type SettleVideoGenerationReadyInput = OperationMutationInput & {
+    fileId: string;
+    bucket: string;
+    objectKey: string;
+    sizeBytes: number;
+    sha256: string;
+    facts: GeneratedVideoFacts;
+};
+export declare function settleVideoGenerationReady(db: Database, input: SettleVideoGenerationReadyInput): Promise<{
+    operation: VideoGenerationOperation;
+    artifact: GeneratedVideoArtifact;
+}>;
+export declare function getGeneratedVideoArtifact(db: Database, workspaceId: string, artifactId: string): Promise<{
+    artifact: GeneratedVideoArtifact;
+    file: typeof schema.files.$inferSelect;
+} | null>;
+export declare function listSessionGeneratedVideoArtifacts(db: Database, workspaceId: string, sessionId: string): Promise<Array<{
+    artifact: GeneratedVideoArtifact;
+    file: typeof schema.files.$inferSelect;
+}>>;
+/**
+ * Record one staging object as erased only after the object-store delete has
+ * succeeded. Deleting first is safe because object deletion is idempotent; a
+ * crash before this CAS simply repeats the same delete on recovery.
+ */
+export declare function markVideoGenerationReferenceCleaned(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    ordinal: number;
+    stagingObjectKey: string;
+}): Promise<boolean>;
+export declare function markVideoGenerationTerminalUpdate(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    state: "leased" | "delivered" | "suppressed";
+    updateId?: string;
+}): Promise<boolean>;
+export declare function markVideoGenerationTerminalUpdateInTransaction(tx: Database, input: {
+    workspaceId: string;
+    operationId: string;
+    state: "leased" | "delivered" | "suppressed";
+    updateId?: string;
+}): Promise<boolean>;
+export declare function mediaGenerationResultForOperation(input: {
+    operation: VideoGenerationOperation;
+    readyReceipt?: Extract<MediaGenerationResult, {
+        status: "ready";
+    }>["receipt"];
+}): MediaGenerationResult;
+/** Build the compact public/model terminal envelope from durable canonical rows. */
+export declare function mediaGenerationResultForStoredOperation(db: Database, operation: VideoGenerationOperation): Promise<MediaGenerationResult>;
+export declare function getVideoGenerationOperationSummary(db: Database, workspaceId: string, operationId: string): Promise<import("@opengeni/contracts").VideoGenerationOperationSummary | null>;
+type OperationMutationInput = {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    requestDigest: string;
+};
+export {};

package/dist/video-generation.js

@@ -0,0 +1,68 @@
+import {
+  ACTIVE_VIDEO_GENERATION_STATUSES,
+  VideoGenerationCapacityError,
+  VideoGenerationConflictError,
+  VideoGenerationCreditError,
+  admitVideoGenerationOperation,
+  cancelUnacceptedVideoGenerationsForToolCallsInTransaction,
+  cancelVideoGenerationBeforeSubmit,
+  claimVideoGenerationOperations,
+  getGeneratedVideoArtifact,
+  getVideoGenerationOperation,
+  getVideoGenerationOperationSummary,
+  getWorkspaceVideoGenerationPolicy,
+  listSessionGeneratedVideoArtifacts,
+  markVideoGenerationAccepted,
+  markVideoGenerationAcceptedInTransaction,
+  markVideoGenerationPrepared,
+  markVideoGenerationProviderStarted,
+  markVideoGenerationReferenceCleaned,
+  markVideoGenerationRetaining,
+  markVideoGenerationSubmissionIntent,
+  markVideoGenerationSubmissionUncertain,
+  markVideoGenerationTerminalUpdate,
+  markVideoGenerationTerminalUpdateInTransaction,
+  mediaGenerationResultForOperation,
+  mediaGenerationResultForStoredOperation,
+  rescheduleVideoGenerationOperation,
+  rotateVideoGenerationCredential,
+  settleVideoGenerationFailure,
+  settleVideoGenerationReady,
+  updateWorkspaceVideoGenerationPolicy
+} from "./chunk-CQZ4QSP5.js";
+import "./chunk-JC5QPLUM.js";
+import "./chunk-5KTIEDX7.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ACTIVE_VIDEO_GENERATION_STATUSES,
+  VideoGenerationCapacityError,
+  VideoGenerationConflictError,
+  VideoGenerationCreditError,
+  admitVideoGenerationOperation,
+  cancelUnacceptedVideoGenerationsForToolCallsInTransaction,
+  cancelVideoGenerationBeforeSubmit,
+  claimVideoGenerationOperations,
+  getGeneratedVideoArtifact,
+  getVideoGenerationOperation,
+  getVideoGenerationOperationSummary,
+  getWorkspaceVideoGenerationPolicy,
+  listSessionGeneratedVideoArtifacts,
+  markVideoGenerationAccepted,
+  markVideoGenerationAcceptedInTransaction,
+  markVideoGenerationPrepared,
+  markVideoGenerationProviderStarted,
+  markVideoGenerationReferenceCleaned,
+  markVideoGenerationRetaining,
+  markVideoGenerationSubmissionIntent,
+  markVideoGenerationSubmissionUncertain,
+  markVideoGenerationTerminalUpdate,
+  markVideoGenerationTerminalUpdateInTransaction,
+  mediaGenerationResultForOperation,
+  mediaGenerationResultForStoredOperation,
+  rescheduleVideoGenerationOperation,
+  rotateVideoGenerationCredential,
+  settleVideoGenerationFailure,
+  settleVideoGenerationReady,
+  updateWorkspaceVideoGenerationPolicy
+};
+//# sourceMappingURL=video-generation.js.map

package/dist/video-generation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/workspace-artifacts.d.ts

@@ -1,5 +1,5 @@
 import type { WorkspaceArtifact, WorkspaceArtifactDetailResponse, WorkspaceArtifactMutationResponse, WorkspaceArtifactVersion } from "@opengeni/contracts";
-import type { Database } from "./database";
+import type { Database } from "./database.js";
 type ArtifactMutationToolName = "artifacts_create" | "artifacts_publish" | "artifacts_rollback";
 export declare class WorkspaceArtifactNotFoundError extends Error {
     readonly name = "WorkspaceArtifactNotFoundError";

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

@@ -1,6 +1,6 @@
 import { WorkspaceInstructionPolicySnapshot } from "@opengeni/contracts";
 import type { WorkspaceInstructionPolicyActivationResponse, WorkspaceInstructionPolicyDiffResponse, WorkspaceInstructionPolicyDraftProvenanceSource, WorkspaceInstructionPolicyHead, WorkspaceInstructionPolicyListQuery, WorkspaceInstructionPolicyListResponse, WorkspaceInstructionPolicyOnboardingProposal, WorkspaceInstructionPolicyOnboardingProposalListQuery, WorkspaceInstructionPolicyOnboardingProposalListResponse, WorkspaceInstructionPolicyProvenanceSource, WorkspaceInstructionPolicyRevision, WorkspaceInstructionPolicyTarget } from "@opengeni/contracts";
-import type { Database } from "./database";
+import type { Database } from "./database.js";
 type DraftRequestInput = WorkspaceInstructionPolicyTarget & {
     operationId: string;
     accountId: string;