or3-provider-sqlite 0.0.8 → 0.0.10

package/dist/runtime/server/db/migrations/017_background_jobs.js

@@ -0,0 +1,42 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        CREATE TABLE IF NOT EXISTS background_jobs (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            thread_id TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            model TEXT NOT NULL,
+            kind TEXT,
+            status TEXT NOT NULL,
+            content TEXT NOT NULL DEFAULT '',
+            chunks_received INTEGER NOT NULL DEFAULT 0,
+            started_at INTEGER NOT NULL,
+            last_activity_at INTEGER NOT NULL,
+            completed_at INTEGER,
+            error TEXT,
+            tool_calls_json TEXT,
+            workflow_state_json TEXT,
+            execution_json TEXT,
+            idempotency_key TEXT UNIQUE,
+            lease_owner TEXT,
+            lease_expires_at INTEGER,
+            attempts INTEGER NOT NULL DEFAULT 0
+        )
+    `.execute(db);
+  await sql`
+        CREATE INDEX IF NOT EXISTS background_jobs_active
+        ON background_jobs(status, last_activity_at)
+    `.execute(db);
+  await sql`
+        CREATE INDEX IF NOT EXISTS background_jobs_user_active
+        ON background_jobs(user_id, status)
+    `.execute(db);
+  await sql`
+        CREATE INDEX IF NOT EXISTS background_jobs_claim
+        ON background_jobs(status, lease_expires_at, started_at)
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`DROP TABLE IF EXISTS background_jobs`.execute(db);
+}

package/dist/runtime/server/db/migrations/018_background_admission_cancels.d.ts

@@ -0,0 +1,7 @@
+import { type Kysely } from 'kysely';
+/**
+ * Durable admission cancellations. Creation and cancellation both check this
+ * table so a Stop that arrives before the job row commits cannot launch work.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/018_background_admission_cancels.js

@@ -0,0 +1,18 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        CREATE TABLE IF NOT EXISTS background_admission_cancels (
+            user_id TEXT NOT NULL,
+            admission_id TEXT NOT NULL,
+            expires_at INTEGER NOT NULL,
+            PRIMARY KEY (user_id, admission_id)
+        )
+    `.execute(db);
+  await sql`
+        CREATE INDEX IF NOT EXISTS background_admission_cancels_expiry
+        ON background_admission_cancels(expires_at)
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`DROP TABLE IF EXISTS background_admission_cancels`.execute(db);
+}

package/dist/runtime/server/db/migrations/019_background_generation_history.d.ts

@@ -0,0 +1,7 @@
+import { type Kysely } from 'kysely';
+/**
+ * Generation identity, durable history phase, and accumulated reasoning on
+ * background jobs. Reasoning is kept distinct from request reasoning config.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/019_background_generation_history.js

@@ -0,0 +1,25 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN reasoning TEXT NOT NULL DEFAULT ''
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN generation_id TEXT
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN history_phase TEXT
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN sync_provider_id TEXT
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`ALTER TABLE background_jobs DROP COLUMN sync_provider_id`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN history_phase`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN generation_id`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN reasoning`.execute(db);
+}

package/dist/runtime/server/db/migrations/020_background_generation_receipts.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+/** Durable replay receipts for canonical background-history transactions. */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/020_background_generation_receipts.js

@@ -0,0 +1,19 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        CREATE TABLE background_generation_receipts (
+            id TEXT PRIMARY KEY,
+            workspace_id TEXT NOT NULL,
+            generation_id TEXT NOT NULL,
+            stage TEXT NOT NULL CHECK(stage IN ('admission', 'finalization')),
+            fingerprint TEXT NOT NULL,
+            outcome TEXT NOT NULL,
+            server_version INTEGER,
+            created_at INTEGER NOT NULL,
+            UNIQUE(workspace_id, generation_id, stage)
+        )
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`DROP TABLE IF EXISTS background_generation_receipts`.execute(db);
+}

package/dist/runtime/server/db/schema.d.ts

@@ -188,6 +188,42 @@ export interface RateLimitsTable {
     window_started_at: number;
     expires_at: number;
 }
+export interface BackgroundJobsTable {
+    id: string;
+    user_id: string;
+    thread_id: string;
+    message_id: string;
+    model: string;
+    kind: string | null;
+    status: 'streaming' | 'complete' | 'error' | 'aborted';
+    content: string;
+    reasoning: string;
+    generation_id: string | null;
+    history_phase: string | null;
+    sync_provider_id: string | null;
+    chunks_received: number;
+    started_at: number;
+    last_activity_at: number;
+    completed_at: number | null;
+    error: string | null;
+    tool_calls_json: string | null;
+    workflow_state_json: string | null;
+    execution_json: string | null;
+    idempotency_key: string | null;
+    lease_owner: string | null;
+    lease_expires_at: number | null;
+    attempts: number;
+}
+export interface BackgroundGenerationReceiptsTable {
+    id: string;
+    workspace_id: string;
+    generation_id: string;
+    stage: 'admission' | 'finalization';
+    fingerprint: string;
+    outcome: string;
+    server_version: number | null;
+    created_at: number;
+}
 export interface AdminUsersTable {
     user_id: string;
     created_at: number;
@@ -216,6 +252,8 @@ export interface Or3SqliteDb {
     connect_device_authorizations: ConnectDeviceAuthorizationsTable;
     connect_environments: ConnectEnvironmentsTable;
     rate_limits: RateLimitsTable;
+    background_jobs: BackgroundJobsTable;
+    background_generation_receipts: BackgroundGenerationReceiptsTable;
     s_threads: SyncedEntityTable;
     s_messages: SyncedEntityTable;
     s_projects: SyncedEntityTable;

package/dist/runtime/server/plugins/register.js

@@ -6,6 +6,7 @@ import { registerSyncGatewayAdapter } from "~~/server/sync/gateway/registry";
 import { registerWebhookStore } from "~~/server/utils/webhooks/store/registry";
 import { registerConnectStore } from "~~/server/connect/store/registry";
 import { registerRateLimitProvider } from "~~/server/utils/rate-limit/registry";
+import { registerBackgroundJobProvider } from "~~/server/utils/background-jobs/registry";
 import { createSqliteAuthWorkspaceStore } from "../auth/sqlite-auth-workspace-store.js";
 import { createSqliteSyncGatewayAdapter } from "../sync/sqlite-sync-gateway-adapter.js";
 import { createSqliteWebhookStore } from "../webhooks/sqlite-webhook-store.js";
@@ -19,6 +20,7 @@ import { createSqliteConnectStore } from "../connect/sqlite-connect-store.js";
 import { getSqliteDriver, initializeSqliteDb } from "../db/kysely.js";
 import { runMigrations } from "../db/migrate.js";
 import { sqliteRateLimitProvider } from "../rate-limit/sqlite-provider.js";
+import { sqliteBackgroundJobProvider } from "../background-jobs/sqlite-provider.js";
 import { useRuntimeConfig } from "#imports";
 const SQLITE_PROVIDER_ID = "sqlite";
 let d1RuntimeInitialization;
@@ -27,7 +29,8 @@ export default defineNitroPlugin(async (nitroApp) => {
   if (!config.auth?.enabled) return;
   const syncSelected = config.sync?.enabled === true && config.sync?.provider === SQLITE_PROVIDER_ID;
   const connectSelected = config.connect?.enabled === true && config.connect?.provider === SQLITE_PROVIDER_ID;
-  if (!syncSelected && !connectSelected) return;
+  const backgroundJobsSelected = config.backgroundJobs?.enabled === true && config.backgroundJobs?.storageProvider === SQLITE_PROVIDER_ID;
+  if (!syncSelected && !connectSelected && !backgroundJobsSelected) return;
   const driver = getSqliteDriver();
   if (driver === "d1" && connectSelected) {
     throw new Error(
@@ -40,6 +43,10 @@ export default defineNitroPlugin(async (nitroApp) => {
     create: createSqliteAuthWorkspaceStore
   });
   registerRateLimitProvider(SQLITE_PROVIDER_ID, sqliteRateLimitProvider);
+  registerBackgroundJobProvider(
+    SQLITE_PROVIDER_ID,
+    sqliteBackgroundJobProvider
+  );
   if (syncSelected) {
     registerSyncGatewayAdapter({
       id: SQLITE_PROVIDER_ID,

package/dist/runtime/server/sync/history-gc-policy.d.ts

@@ -11,3 +11,11 @@ export declare const SYNC_HISTORY_GC_POLICY: Readonly<{
     reason: "SQLite history GC is guarded by the verified snapshot-v1 retention contract.";
 }>;
 export declare function canRunSyncHistoryGc(): boolean;
+export declare function computePullRetention(input: {
+    cursor: number;
+    oldestLogVersion: number | null;
+    highWatermark: number;
+}): {
+    oldestRetainedVersion: number;
+    requiresSnapshot: boolean;
+};

package/dist/runtime/server/sync/history-gc-policy.js

@@ -6,3 +6,10 @@ export const SYNC_HISTORY_GC_POLICY = Object.freeze({
 export function canRunSyncHistoryGc() {
   return SYNC_HISTORY_GC_POLICY.enabled && SYNC_HISTORY_GC_POLICY.snapshotBootstrapVerified;
 }
+export function computePullRetention(input) {
+  const oldestRetainedVersion = input.oldestLogVersion ?? Math.max(0, input.highWatermark) + 1;
+  return {
+    oldestRetainedVersion,
+    requiresSnapshot: oldestRetainedVersion > 0 && input.cursor < Math.max(0, oldestRetainedVersion - 1)
+  };
+}

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.d.ts

@@ -7,14 +7,26 @@
  */
 import type { H3Event } from 'h3';
 import type { CanonicalStorageQueryRequest, CanonicalStorageQueryResponse, SyncGatewayAdapter, SyncMaintenanceState, UploadIntentConsumptionRequest, UploadIntentReservationRequest } from '~~/server/sync/gateway/types';
+import type { AdmitChatGenerationResult, CanonicalGenerationSnapshot, CanonicalHistoryActor, ChatGenerationAdmissionEnvelope, FinalizeChatGenerationResult } from '~~/shared/chat/background-history';
 import type { PullRequest, PullResponse, PushBatch, PushResult, SnapshotRequest, SnapshotResponse } from '~~/shared/sync/types';
 export declare class SqliteSyncGatewayAdapter implements SyncGatewayAdapter {
     id: string;
-    readonly capabilities: {
+    get capabilities(): {
         readonly snapshotBootstrap: "snapshot-v1";
         readonly historyRetention: "snapshot-v1";
+        readonly backgroundGenerationHistory?: undefined;
+    } | {
+        readonly snapshotBootstrap: "snapshot-v1";
+        readonly historyRetention: "snapshot-v1";
+        readonly backgroundGenerationHistory: "v1";
     };
     private get db();
+    private assertCanonicalActor;
+    admitChatGeneration(actor: CanonicalHistoryActor, input: ChatGenerationAdmissionEnvelope): Promise<AdmitChatGenerationResult>;
+    finalizeChatGeneration(actor: CanonicalHistoryActor, input: {
+        admission: ChatGenerationAdmissionEnvelope;
+        snapshot: CanonicalGenerationSnapshot;
+    }): Promise<FinalizeChatGenerationResult>;
     reserveUploadIntent(event: H3Event, input: UploadIntentReservationRequest): Promise<void>;
     consumeUploadIntent(event: H3Event, input: UploadIntentConsumptionRequest): Promise<void>;
     cancelUploadIntent(event: H3Event, input: {