@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/storage/modelProviderConnectionStore.d.ts

@@ -0,0 +1,99 @@
+import type { DatabaseAdapter } from './databaseAdapter.js';
+export type ModelProviderConnectionLifecycleStatus = 'pending' | 'active' | 'reconnect_required' | 'disconnected' | 'revoked';
+export interface ModelProviderConnectionDisplayMetadata {
+    displayName?: string;
+    accountLabel?: string;
+    accountEmail?: string;
+    planLabel?: string;
+}
+export interface ModelProviderConnectionRecord {
+    id: string;
+    tenantId: string;
+    ownerUserId: string;
+    providerKey: string;
+    authenticationType: string;
+    lifecycleStatus: ModelProviderConnectionLifecycleStatus;
+    displayMetadata: ModelProviderConnectionDisplayMetadata;
+    credentialHomeRef: string;
+    lastVerifiedAt: string | null;
+    lastRefreshedAt: string | null;
+    lastFailureAt: string | null;
+    failureCode: string | null;
+    disconnectedAt: string | null;
+    revokedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelProviderConnectionLease {
+    connectionId: string;
+    token: string;
+    operation: string;
+    acquiredAt: string;
+    expiresAt: string;
+}
+export declare class ModelProviderConnectionError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(message: string, statusCode: number, code: string);
+}
+export declare function sanitizeModelProviderConnectionDisplayMetadata(value: unknown): ModelProviderConnectionDisplayMetadata;
+export declare class ModelProviderConnectionStore {
+    private readonly db;
+    private readonly tenantId;
+    private readonly now;
+    constructor(db: DatabaseAdapter, tenantId: string, now?: () => Date);
+    private leaseNow;
+    private leaseClockPredicate;
+    create(input: {
+        ownerUserId: string;
+        providerKey: string;
+        authenticationType: string;
+        displayMetadata?: unknown;
+    }): ModelProviderConnectionRecord;
+    listOwned(ownerUserIdRaw: string): ModelProviderConnectionRecord[];
+    getOwned(ownerUserIdRaw: string, connectionIdRaw: string): ModelProviderConnectionRecord | null;
+    requireOwned(ownerUserId: string, connectionId: string): ModelProviderConnectionRecord;
+    renameOwned(ownerUserId: string, connectionId: string, displayNameRaw: unknown): ModelProviderConnectionRecord;
+    requireOwnedUnderLease(ownerUserId: string, connectionId: string, leaseToken: string): ModelProviderConnectionRecord;
+    deletePendingOwned(ownerUserId: string, connectionId: string): boolean;
+    acquireLease(input: {
+        ownerUserId: string;
+        connectionId: string;
+        operation: string;
+        durationMs?: number;
+    }): ModelProviderConnectionLease;
+    renewLease(lease: ModelProviderConnectionLease, durationMs?: number): boolean;
+    releaseLease(lease: ModelProviderConnectionLease): boolean;
+    completeLease(lease: ModelProviderConnectionLease): boolean;
+    deleteCleanableUnderLease(input: {
+        ownerUserId: string;
+        connectionId: string;
+        leaseToken: string;
+    }): boolean;
+    markVerified(input: {
+        ownerUserId: string;
+        connectionId: string;
+        leaseToken: string;
+        displayMetadata?: unknown;
+    }): ModelProviderConnectionRecord;
+    markRefreshed(input: {
+        ownerUserId: string;
+        connectionId: string;
+        leaseToken: string;
+        displayMetadata?: unknown;
+    }): ModelProviderConnectionRecord;
+    markReconnectRequired(input: {
+        ownerUserId: string;
+        connectionId: string;
+        leaseToken: string;
+        failureCode: string;
+    }): ModelProviderConnectionRecord;
+    markDisconnected(input: {
+        ownerUserId: string;
+        connectionId: string;
+        leaseToken: string;
+    }): ModelProviderConnectionRecord;
+    private updateUnderLease;
+    private updateUnderLeaseTransaction;
+    private insertEvent;
+}

package/dist/storage/modelProviderConnectionStore.js

@@ -0,0 +1,446 @@
+import { randomBytes } from 'node:crypto';
+export class ModelProviderConnectionError extends Error {
+    statusCode;
+    code;
+    constructor(message, statusCode, code) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'ModelProviderConnectionError';
+    }
+}
+const SAFE_METADATA_KEYS = ['accountLabel', 'accountEmail', 'planLabel'];
+const MAX_DISPLAY_NAME_LENGTH = 80;
+const POSTGRES_LEASE_CLOCK_SQL = `TO_CHAR(
+    clock_timestamp() AT TIME ZONE 'UTC',
+    'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+)`;
+const POSTGRES_LEASE_EXPIRY_SQL = `TO_CHAR(
+    (clock_timestamp() + (CAST(? AS BIGINT) * INTERVAL '1 millisecond')) AT TIME ZONE 'UTC',
+    'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+)`;
+function randomOpaqueId(prefix) {
+    return `${prefix}_${randomBytes(24).toString('base64url')}`;
+}
+function normalizeIdentifier(value, label) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!/^[a-z][a-z0-9._-]{0,63}$/.test(normalized)) {
+        throw new ModelProviderConnectionError(`${label} is invalid.`, 400, 'MODEL_CONNECTION_INVALID_INPUT');
+    }
+    return normalized;
+}
+export function sanitizeModelProviderConnectionDisplayMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const source = value;
+    const result = {};
+    for (const key of SAFE_METADATA_KEYS) {
+        const normalized = typeof source[key] === 'string'
+            ? String(source[key]).trim().slice(0, 200)
+            : '';
+        const sanitized = normalized
+            .replace(/sk-[A-Za-z0-9_-]{8,}/g, '[redacted]')
+            .replace(/(Bearer\s+)[^\s]+/gi, '$1[redacted]')
+            .replace(/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\b/g, '[redacted]');
+        if (sanitized)
+            result[key] = sanitized;
+    }
+    return result;
+}
+function normalizeDisplayName(value) {
+    if (typeof value !== 'string') {
+        throw new ModelProviderConnectionError('Display name must be a nonempty string of at most 80 characters.', 400, 'MODEL_CONNECTION_INVALID_DISPLAY_NAME');
+    }
+    const displayName = value.trim();
+    if (!displayName || displayName.length > MAX_DISPLAY_NAME_LENGTH) {
+        throw new ModelProviderConnectionError('Display name must be a nonempty string of at most 80 characters.', 400, 'MODEL_CONNECTION_INVALID_DISPLAY_NAME');
+    }
+    return displayName;
+}
+function parseDisplayMetadata(value) {
+    try {
+        const parsed = JSON.parse(String(value || '{}'));
+        const metadata = sanitizeModelProviderConnectionDisplayMetadata(parsed);
+        if (typeof parsed.displayName === 'string') {
+            const displayName = parsed.displayName.trim().slice(0, MAX_DISPLAY_NAME_LENGTH);
+            if (displayName)
+                metadata.displayName = displayName;
+        }
+        return metadata;
+    }
+    catch {
+        return {};
+    }
+}
+function mapRow(row) {
+    const status = String(row.lifecycle_status || 'pending');
+    return {
+        id: String(row.id || ''),
+        tenantId: String(row.tenant_id || 'default'),
+        ownerUserId: String(row.owner_user_id || ''),
+        providerKey: String(row.provider_key || ''),
+        authenticationType: String(row.authentication_type || ''),
+        lifecycleStatus: status,
+        displayMetadata: parseDisplayMetadata(row.display_metadata_json),
+        credentialHomeRef: String(row.credential_home_ref || ''),
+        lastVerifiedAt: row.last_verified_at ? String(row.last_verified_at) : null,
+        lastRefreshedAt: row.last_refreshed_at ? String(row.last_refreshed_at) : null,
+        lastFailureAt: row.last_failure_at ? String(row.last_failure_at) : null,
+        failureCode: row.failure_code ? String(row.failure_code) : null,
+        disconnectedAt: row.disconnected_at ? String(row.disconnected_at) : null,
+        revokedAt: row.revoked_at ? String(row.revoked_at) : null,
+        createdAt: String(row.created_at || ''),
+        updatedAt: String(row.updated_at || ''),
+    };
+}
+export class ModelProviderConnectionStore {
+    db;
+    tenantId;
+    now;
+    constructor(db, tenantId, now = () => new Date()) {
+        this.db = db;
+        this.tenantId = tenantId;
+        this.now = now;
+    }
+    leaseNow() {
+        if (this.db.provider === 'sqlite')
+            return this.now();
+        const row = this.db.prepare(`
+            SELECT ${POSTGRES_LEASE_CLOCK_SQL} AS current_time
+        `).get();
+        const currentTime = new Date(String(row?.current_time || ''));
+        if (Number.isNaN(currentTime.getTime())) {
+            throw new Error('[Taskforce] PostgreSQL did not return a valid lease clock value.');
+        }
+        return currentTime;
+    }
+    leaseClockPredicate(nowIso) {
+        return this.db.provider === 'postgres'
+            ? { sql: POSTGRES_LEASE_CLOCK_SQL, params: [] }
+            : { sql: '?', params: [nowIso] };
+    }
+    create(input) {
+        const ownerUserId = String(input.ownerUserId || '').trim();
+        if (!ownerUserId) {
+            throw new ModelProviderConnectionError('Authentication is required.', 401, 'AUTH_REQUIRED');
+        }
+        const providerKey = normalizeIdentifier(input.providerKey, 'Provider key');
+        const authenticationType = normalizeIdentifier(input.authenticationType, 'Authentication type');
+        const id = randomOpaqueId('mpc');
+        const credentialHomeRef = randomOpaqueId('home');
+        const now = this.now().toISOString();
+        const displayMetadata = sanitizeModelProviderConnectionDisplayMetadata(input.displayMetadata);
+        this.db.transaction(() => {
+            this.db.prepare(`
+                INSERT INTO model_provider_connections (
+                    id, tenant_id, owner_user_id, provider_key, authentication_type,
+                    lifecycle_status, display_metadata_json, credential_home_ref,
+                    created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?)
+            `).run(id, this.tenantId, ownerUserId, providerKey, authenticationType, JSON.stringify(displayMetadata), credentialHomeRef, now, now);
+            this.insertEvent({
+                connectionId: id,
+                ownerUserId,
+                actorUserId: ownerUserId,
+                eventType: 'created',
+                outcome: 'success',
+                createdAt: now,
+            });
+        })();
+        return this.requireOwned(ownerUserId, id);
+    }
+    listOwned(ownerUserIdRaw) {
+        const ownerUserId = String(ownerUserIdRaw || '').trim();
+        if (!ownerUserId)
+            return [];
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM model_provider_connections
+            WHERE tenant_id = ? AND owner_user_id = ?
+            ORDER BY created_at ASC, id ASC
+        `).all(this.tenantId, ownerUserId);
+        return rows.map(mapRow);
+    }
+    getOwned(ownerUserIdRaw, connectionIdRaw) {
+        const ownerUserId = String(ownerUserIdRaw || '').trim();
+        const connectionId = String(connectionIdRaw || '').trim();
+        if (!ownerUserId || !connectionId)
+            return null;
+        const row = this.db.prepare(`
+            SELECT *
+            FROM model_provider_connections
+            WHERE tenant_id = ? AND owner_user_id = ? AND id = ?
+            LIMIT 1
+        `).get(this.tenantId, ownerUserId, connectionId);
+        return row ? mapRow(row) : null;
+    }
+    requireOwned(ownerUserId, connectionId) {
+        const connection = this.getOwned(ownerUserId, connectionId);
+        if (!connection) {
+            throw new ModelProviderConnectionError('Model connection was not found.', 404, 'MODEL_CONNECTION_NOT_FOUND');
+        }
+        return connection;
+    }
+    renameOwned(ownerUserId, connectionId, displayNameRaw) {
+        const displayName = normalizeDisplayName(displayNameRaw);
+        return this.db.transaction(() => {
+            const current = this.requireOwned(ownerUserId, connectionId);
+            const now = this.now().toISOString();
+            const result = this.db.prepare(`
+                UPDATE model_provider_connections
+                SET display_metadata_json = ?, updated_at = ?
+                WHERE tenant_id = ? AND owner_user_id = ? AND id = ?
+            `).run(JSON.stringify({ ...current.displayMetadata, displayName }), now, this.tenantId, ownerUserId, connectionId);
+            if (Number(result?.changes || 0) !== 1) {
+                throw new ModelProviderConnectionError('Model connection was not found.', 404, 'MODEL_CONNECTION_NOT_FOUND');
+            }
+            this.insertEvent({
+                connectionId,
+                ownerUserId,
+                actorUserId: ownerUserId,
+                eventType: 'renamed',
+                outcome: 'success',
+                createdAt: now,
+            });
+            return this.requireOwned(ownerUserId, connectionId);
+        })();
+    }
+    requireOwnedUnderLease(ownerUserId, connectionId, leaseToken) {
+        const now = this.leaseNow().toISOString();
+        const clock = this.leaseClockPredicate(now);
+        const row = this.db.prepare(`
+            SELECT connection.*
+            FROM model_provider_connections connection
+            WHERE connection.tenant_id = ? AND connection.owner_user_id = ? AND connection.id = ?
+              AND EXISTS (
+                SELECT 1 FROM model_provider_connection_leases lease
+                WHERE lease.tenant_id = connection.tenant_id
+                  AND lease.connection_id = connection.id
+                  AND lease.lease_token = ?
+                  AND lease.expires_at > ${clock.sql}
+              )
+            LIMIT 1
+        `).get(this.tenantId, ownerUserId, connectionId, leaseToken, ...clock.params);
+        if (!row) {
+            throw new ModelProviderConnectionError('Model connection operation lease is no longer valid.', 409, 'MODEL_CONNECTION_LEASE_LOST');
+        }
+        return mapRow(row);
+    }
+    deletePendingOwned(ownerUserId, connectionId) {
+        return this.db.transaction(() => {
+            const result = this.db.prepare(`
+                DELETE FROM model_provider_connections
+                WHERE tenant_id = ? AND owner_user_id = ? AND id = ? AND lifecycle_status = 'pending'
+            `).run(this.tenantId, ownerUserId, connectionId);
+            if (Number(result?.changes || 0) === 1) {
+                this.db.prepare(`
+                    DELETE FROM model_provider_connection_events
+                    WHERE tenant_id = ? AND connection_id = ?
+                `).run(this.tenantId, connectionId);
+                return true;
+            }
+            return false;
+        })();
+    }
+    acquireLease(input) {
+        this.requireOwned(input.ownerUserId, input.connectionId);
+        const operation = normalizeIdentifier(input.operation, 'Connection operation');
+        const durationMs = Math.min(10 * 60_000, Math.max(1_000, input.durationMs ?? 120_000));
+        const token = randomOpaqueId('lease');
+        if (this.db.provider === 'postgres') {
+            const row = this.db.prepare(`
+                INSERT INTO model_provider_connection_leases (
+                    tenant_id, connection_id, lease_token, operation, acquired_at, expires_at, updated_at
+                ) VALUES (
+                    ?, ?, ?, ?, ${POSTGRES_LEASE_CLOCK_SQL}, ${POSTGRES_LEASE_EXPIRY_SQL}, ${POSTGRES_LEASE_CLOCK_SQL}
+                )
+                ON CONFLICT (tenant_id, connection_id) DO UPDATE SET
+                    lease_token = excluded.lease_token,
+                    operation = excluded.operation,
+                    acquired_at = ${POSTGRES_LEASE_CLOCK_SQL},
+                    expires_at = ${POSTGRES_LEASE_EXPIRY_SQL},
+                    updated_at = ${POSTGRES_LEASE_CLOCK_SQL}
+                WHERE model_provider_connection_leases.expires_at <= ${POSTGRES_LEASE_CLOCK_SQL}
+                RETURNING acquired_at, expires_at
+            `).get(this.tenantId, input.connectionId, token, operation, durationMs, durationMs);
+            if (!row) {
+                throw new ModelProviderConnectionError('Model connection is busy. Try again shortly.', 409, 'MODEL_CONNECTION_BUSY');
+            }
+            return {
+                connectionId: input.connectionId,
+                token,
+                operation,
+                acquiredAt: String(row.acquired_at || ''),
+                expiresAt: String(row.expires_at || ''),
+            };
+        }
+        const acquiredAt = this.leaseNow();
+        const acquiredAtIso = acquiredAt.toISOString();
+        const expiresAt = new Date(acquiredAt.getTime() + durationMs).toISOString();
+        const result = this.db.prepare(`
+            INSERT INTO model_provider_connection_leases (
+                tenant_id, connection_id, lease_token, operation, acquired_at, expires_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (tenant_id, connection_id) DO UPDATE SET
+                lease_token = excluded.lease_token,
+                operation = excluded.operation,
+                acquired_at = excluded.acquired_at,
+                expires_at = excluded.expires_at,
+                updated_at = excluded.updated_at
+            WHERE model_provider_connection_leases.expires_at <= excluded.acquired_at
+        `).run(this.tenantId, input.connectionId, token, operation, acquiredAtIso, expiresAt, acquiredAtIso);
+        if (Number(result?.changes || 0) !== 1) {
+            throw new ModelProviderConnectionError('Model connection is busy. Try again shortly.', 409, 'MODEL_CONNECTION_BUSY');
+        }
+        return { connectionId: input.connectionId, token, operation, acquiredAt: acquiredAtIso, expiresAt };
+    }
+    renewLease(lease, durationMs = 120_000) {
+        const boundedDurationMs = Math.min(10 * 60_000, Math.max(1_000, durationMs));
+        if (this.db.provider === 'postgres') {
+            const row = this.db.prepare(`
+                UPDATE model_provider_connection_leases
+                SET expires_at = ${POSTGRES_LEASE_EXPIRY_SQL},
+                    updated_at = ${POSTGRES_LEASE_CLOCK_SQL}
+                WHERE tenant_id = ? AND connection_id = ? AND lease_token = ?
+                  AND expires_at > ${POSTGRES_LEASE_CLOCK_SQL}
+                RETURNING expires_at
+            `).get(boundedDurationMs, this.tenantId, lease.connectionId, lease.token);
+            return Boolean(row);
+        }
+        const now = this.leaseNow();
+        const nowIso = now.toISOString();
+        const expiresAt = new Date(now.getTime() + boundedDurationMs).toISOString();
+        const clock = this.leaseClockPredicate(nowIso);
+        const result = this.db.prepare(`
+            UPDATE model_provider_connection_leases
+            SET expires_at = ?, updated_at = ?
+            WHERE tenant_id = ? AND connection_id = ? AND lease_token = ? AND expires_at > ${clock.sql}
+        `).run(expiresAt, nowIso, this.tenantId, lease.connectionId, lease.token, ...clock.params);
+        return Number(result?.changes || 0) === 1;
+    }
+    releaseLease(lease) {
+        const result = this.db.prepare(`
+            DELETE FROM model_provider_connection_leases
+            WHERE tenant_id = ? AND connection_id = ? AND lease_token = ?
+        `).run(this.tenantId, lease.connectionId, lease.token);
+        return Number(result?.changes || 0) === 1;
+    }
+    completeLease(lease) {
+        const now = this.leaseNow().toISOString();
+        const clock = this.leaseClockPredicate(now);
+        const result = this.db.prepare(`
+            DELETE FROM model_provider_connection_leases
+            WHERE tenant_id = ? AND connection_id = ? AND lease_token = ? AND expires_at > ${clock.sql}
+        `).run(this.tenantId, lease.connectionId, lease.token, ...clock.params);
+        return Number(result?.changes || 0) === 1;
+    }
+    deleteCleanableUnderLease(input) {
+        return this.db.transaction(() => {
+            const now = this.leaseNow().toISOString();
+            const clock = this.leaseClockPredicate(now);
+            const result = this.db.prepare(`
+                DELETE FROM model_provider_connections
+                WHERE tenant_id = ? AND owner_user_id = ? AND id = ?
+                  AND lifecycle_status IN ('pending', 'reconnect_required', 'disconnected', 'revoked')
+                  AND EXISTS (
+                    SELECT 1 FROM model_provider_connection_leases lease
+                    WHERE lease.tenant_id = model_provider_connections.tenant_id
+                      AND lease.connection_id = model_provider_connections.id
+                      AND lease.lease_token = ?
+                      AND lease.expires_at > ${clock.sql}
+                  )
+            `).run(this.tenantId, input.ownerUserId, input.connectionId, input.leaseToken, ...clock.params);
+            if (Number(result?.changes || 0) !== 1)
+                return false;
+            this.insertEvent({
+                connectionId: input.connectionId,
+                ownerUserId: input.ownerUserId,
+                actorUserId: input.ownerUserId,
+                eventType: 'cleaned_up',
+                outcome: 'success',
+                createdAt: now,
+            });
+            return true;
+        })();
+    }
+    markVerified(input) {
+        return this.updateUnderLease(input, 'active', {
+            displayMetadata: input.displayMetadata,
+            verified: true,
+            eventType: 'verified',
+        });
+    }
+    markRefreshed(input) {
+        return this.updateUnderLease(input, 'active', {
+            displayMetadata: input.displayMetadata,
+            refreshed: true,
+            eventType: 'refreshed',
+        });
+    }
+    markReconnectRequired(input) {
+        return this.updateUnderLease(input, 'reconnect_required', {
+            failureCode: normalizeIdentifier(input.failureCode, 'Failure code'),
+            eventType: 'reconnect_required',
+        });
+    }
+    markDisconnected(input) {
+        return this.updateUnderLease(input, 'disconnected', {
+            disconnected: true,
+            eventType: 'disconnected',
+        });
+    }
+    updateUnderLease(input, lifecycleStatus, options) {
+        return this.db.transaction(() => this.updateUnderLeaseTransaction(input, lifecycleStatus, options))();
+    }
+    updateUnderLeaseTransaction(input, lifecycleStatus, options) {
+        this.requireOwned(input.ownerUserId, input.connectionId);
+        const now = this.leaseNow().toISOString();
+        const clock = this.leaseClockPredicate(now);
+        const current = this.requireOwned(input.ownerUserId, input.connectionId);
+        const displayMetadata = options.displayMetadata === undefined
+            ? current.displayMetadata
+            : {
+                ...current.displayMetadata,
+                ...sanitizeModelProviderConnectionDisplayMetadata(options.displayMetadata),
+            };
+        const result = this.db.prepare(`
+            UPDATE model_provider_connections
+            SET lifecycle_status = ?, display_metadata_json = ?,
+                last_verified_at = CASE WHEN ? = 1 THEN ? ELSE last_verified_at END,
+                last_refreshed_at = CASE WHEN ? = 1 THEN ? ELSE last_refreshed_at END,
+                last_failure_at = CASE WHEN CAST(? AS TEXT) IS NOT NULL THEN ? ELSE NULL END,
+                failure_code = ?,
+                disconnected_at = CASE WHEN ? = 1 THEN ? ELSE disconnected_at END,
+                updated_at = ?
+            WHERE tenant_id = ? AND owner_user_id = ? AND id = ?
+              AND EXISTS (
+                SELECT 1 FROM model_provider_connection_leases lease
+                WHERE lease.tenant_id = model_provider_connections.tenant_id
+                  AND lease.connection_id = model_provider_connections.id
+                  AND lease.lease_token = ?
+                  AND lease.expires_at > ${clock.sql}
+              )
+        `).run(lifecycleStatus, JSON.stringify(displayMetadata), options.verified ? 1 : 0, now, options.refreshed ? 1 : 0, now, options.failureCode || null, now, options.failureCode || null, options.disconnected ? 1 : 0, now, now, this.tenantId, input.ownerUserId, input.connectionId, input.leaseToken, ...clock.params);
+        if (Number(result?.changes || 0) !== 1) {
+            throw new ModelProviderConnectionError('Model connection operation lease is no longer valid.', 409, 'MODEL_CONNECTION_LEASE_LOST');
+        }
+        this.insertEvent({
+            connectionId: input.connectionId,
+            ownerUserId: input.ownerUserId,
+            actorUserId: input.ownerUserId,
+            eventType: options.eventType,
+            outcome: options.failureCode ? 'failure' : 'success',
+            reasonCode: options.failureCode,
+            createdAt: now,
+        });
+        return this.requireOwned(input.ownerUserId, input.connectionId);
+    }
+    insertEvent(input) {
+        this.db.prepare(`
+            INSERT INTO model_provider_connection_events (
+                id, tenant_id, connection_id, owner_user_id, actor_user_id,
+                event_type, outcome, reason_code, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(randomOpaqueId('mpce'), this.tenantId, input.connectionId, input.ownerUserId, input.actorUserId, input.eventType, input.outcome, input.reasonCode || null, input.createdAt);
+    }
+}

package/dist/storage/postgresAdapter.d.ts

@@ -9,6 +9,10 @@ export declare class PostgresWorkerUnavailableError extends Error {
     readonly code = "POSTGRES_WORKER_UNAVAILABLE";
     constructor();
 }
+export declare class PostgresDatabaseError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
 export declare function replaceQMarkParams(sql: string, params: unknown[]): {
     text: string;
     values: unknown[];

package/dist/storage/postgresAdapter.js

@@ -27,6 +27,14 @@ export class PostgresWorkerUnavailableError extends Error {
         this.name = 'PostgresWorkerUnavailableError';
     }
 }
+export class PostgresDatabaseError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'PostgresDatabaseError';
+    }
+}
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -171,8 +179,9 @@ export class PostgresAdapter {
         }
         const waitStartedAt = performance.now();
         const waitResult = Atomics.wait(status, RESPONSE_STATUS_INDEX, RESPONSE_INITIAL, this.deadlines.responseTimeoutMs);
-        recordPostgresWorkerWait(payload.op, performance.now() - waitStartedAt);
+        const workerWaitMs = performance.now() - waitStartedAt;
         if (waitResult === 'timed-out') {
+            recordPostgresWorkerWait(payload.op, workerWaitMs);
             this.quarantineWorker(worker);
             throw new PostgresWorkerOutcomeUnknownError(payload.op);
         }
@@ -182,6 +191,7 @@ export class PostgresAdapter {
         }
         const body = this.decoder.decode(responseBytes.subarray(0, responseLength));
         const parsed = JSON.parse(body);
+        recordPostgresWorkerWait(payload.op, workerWaitMs, parsed.pool);
         this.consecutiveUnexpectedExits = 0;
         if (!parsed.ok && parsed.errorCode === 'RESPONSE_BUFFER_TOO_SMALL') {
             const requiredBytes = Number(parsed.requiredBytes);
@@ -195,6 +205,9 @@ export class PostgresAdapter {
             return this.callWorker({ op: 'read-response', responseToken }, requiredBytes);
         }
         if (!parsed.ok) {
+            if (parsed.databaseErrorCode) {
+                throw new PostgresDatabaseError(parsed.error || 'Unknown Postgres database error', parsed.databaseErrorCode);
+            }
             throw new Error(parsed.error || 'Unknown Postgres worker error');
         }
         return parsed;

package/dist/storage/postgresRequestDiagnostics.d.ts

@@ -2,7 +2,15 @@ export type RequestPerformanceDiagnostics = {
     postgresQueryCount: number;
     postgresWorkerCallCount: number;
     postgresWorkerWaitMs: number;
+    postgresWorkerWaitMaxMs: number;
+    postgresPoolWaitingMax: number;
+    postgresPoolTotalMax: number;
+    postgresPoolIdleMin: number | null;
 };
 export declare function runWithRequestPerformanceDiagnostics<T>(enabled: boolean, callback: () => T): T;
-export declare function recordPostgresWorkerWait(operation: string, durationMs: number): void;
+export declare function recordPostgresWorkerWait(operation: string, durationMs: number, pool?: {
+    totalCount: number;
+    idleCount: number;
+    waitingCount: number;
+}): void;
 export declare function getRequestPerformanceDiagnostics(): RequestPerformanceDiagnostics | null;

package/dist/storage/postgresRequestDiagnostics.js

@@ -7,16 +7,29 @@ export function runWithRequestPerformanceDiagnostics(enabled, callback) {
         postgresQueryCount: 0,
         postgresWorkerCallCount: 0,
         postgresWorkerWaitMs: 0,
+        postgresWorkerWaitMaxMs: 0,
+        postgresPoolWaitingMax: 0,
+        postgresPoolTotalMax: 0,
+        postgresPoolIdleMin: null,
     }, callback);
 }
-export function recordPostgresWorkerWait(operation, durationMs) {
+export function recordPostgresWorkerWait(operation, durationMs, pool) {
     const diagnostics = requestPerformanceStorage.getStore();
     if (!diagnostics)
         return;
     diagnostics.postgresWorkerCallCount += 1;
     if (operation === 'query')
         diagnostics.postgresQueryCount += 1;
-    diagnostics.postgresWorkerWaitMs += Math.max(0, durationMs);
+    const boundedDurationMs = Math.max(0, durationMs);
+    diagnostics.postgresWorkerWaitMs += boundedDurationMs;
+    diagnostics.postgresWorkerWaitMaxMs = Math.max(diagnostics.postgresWorkerWaitMaxMs, boundedDurationMs);
+    if (pool) {
+        diagnostics.postgresPoolWaitingMax = Math.max(diagnostics.postgresPoolWaitingMax, pool.waitingCount);
+        diagnostics.postgresPoolTotalMax = Math.max(diagnostics.postgresPoolTotalMax, pool.totalCount);
+        diagnostics.postgresPoolIdleMin = diagnostics.postgresPoolIdleMin === null
+            ? pool.idleCount
+            : Math.min(diagnostics.postgresPoolIdleMin, pool.idleCount);
+    }
 }
 export function getRequestPerformanceDiagnostics() {
     const diagnostics = requestPerformanceStorage.getStore();