@opengeni/db 0.18.1 → 0.21.0

package/dist/scoped-knowledge.d.ts

@@ -0,0 +1,208 @@
+import type { EligibleKnowledgeClaim, KnowledgeChangeProposalRecord, KnowledgeClaimEvidencePolarity, KnowledgeClaimOrigin, KnowledgeClaimRecord, KnowledgeClaimRelationType, KnowledgeClaimReviewState, KnowledgeDocumentVersionRecord, KnowledgeFactObjectKind, KnowledgeFactRecord, KnowledgeLifecycleEventType, KnowledgeLifecycleState, KnowledgeProviderRecord, KnowledgeSourceAclVersionRecord, KnowledgeSourceObjectRecord, KnowledgeSourceRecord, KnowledgeSyncRunRecord, ScopedKnowledgeActor, ScopedKnowledgeScope } from "@opengeni/contracts";
+import type { Database } from "./index";
+type KnowledgeWriteContext = {
+    accountId: string;
+    workspaceId: string;
+    scope: ScopedKnowledgeScope;
+    operationId: string;
+    actor: ScopedKnowledgeActor;
+};
+type KnowledgeReadContext = {
+    accountId: string;
+    workspaceId: string;
+    initiatingSubjectId: string;
+    surface: "human" | "agent";
+};
+export declare class ScopedKnowledgeConflictError extends Error {
+    readonly name = "ScopedKnowledgeConflictError";
+    readonly code = "SCOPED_KNOWLEDGE_CONFLICT";
+}
+export declare class ScopedKnowledgeGenerationConflictError extends Error {
+    readonly name = "ScopedKnowledgeGenerationConflictError";
+    readonly code = "SCOPED_KNOWLEDGE_GENERATION_CONFLICT";
+}
+export declare class ScopedKnowledgeNotFoundError extends Error {
+    readonly name = "ScopedKnowledgeNotFoundError";
+}
+export declare class ScopedKnowledgeInvalidOperationError extends Error {
+    readonly name = "ScopedKnowledgeInvalidOperationError";
+}
+export declare class ScopedKnowledgeAuthorityError extends Error {
+    readonly name = "ScopedKnowledgeAuthorityError";
+}
+export declare function scopedKnowledgeInputHash(value: unknown): string;
+export declare function normalizeScopedKnowledgeKey(value: string): string;
+export declare function scopedKnowledgeScopeKey(scope: ScopedKnowledgeScope): string;
+export declare function upsertKnowledgeProvider(db: Database, input: KnowledgeWriteContext & {
+    providerKey: string;
+    externalTenantId: string;
+}): Promise<KnowledgeProviderRecord>;
+export declare function upsertKnowledgeSource(db: Database, input: KnowledgeWriteContext & {
+    providerId: string;
+    externalSourceId: string;
+    sourceKind: string;
+    sourceUri?: string | null;
+}): Promise<KnowledgeSourceRecord>;
+export declare function appendKnowledgeSourceAclVersion(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    sourceId: string;
+    audience: ScopedKnowledgeScope;
+    expectedSourceLifecycleGeneration: number;
+    expectedAclGeneration: number;
+    aclVersion?: string | null;
+    agentAccess: boolean;
+    reasonCode: string;
+}): Promise<KnowledgeSourceAclVersionRecord>;
+export declare function beginKnowledgeSyncRun(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    sourceId: string;
+    expectedSourceLifecycleGeneration: number;
+    expectedSyncGeneration: number;
+    inputCursor: string | null;
+}): Promise<KnowledgeSyncRunRecord>;
+export declare function completeKnowledgeSyncRun(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    initiatingSubjectId: string | null;
+    runId: string;
+    state: "succeeded" | "failed";
+    outputCursor?: string | null;
+    watermark?: string | null;
+    metadata?: Record<string, unknown> | undefined;
+    errorCode?: string | null;
+    reasonCode: string;
+}): Promise<KnowledgeSyncRunRecord>;
+export declare function upsertKnowledgeSourceObject(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    sourceId: string;
+    externalObjectId: string;
+    documentId?: string | null;
+}): Promise<KnowledgeSourceObjectRecord>;
+export declare function appendKnowledgeDocumentVersion(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    objectId: string;
+    expectedObjectLifecycleGeneration: number;
+    expectedVersionGeneration: number;
+    externalVersionId: string;
+    contentSha256: string;
+    ingestionKey: string;
+    sourceCursor?: string | null;
+    sourceMetadata?: Record<string, unknown> | undefined;
+    sourceCreatedAt?: string | null;
+    sourceUpdatedAt?: string | null;
+    aclVersionId: string;
+    aclGeneration: number;
+    documentId?: string | null;
+    fileId?: string | null;
+    locationMetadata?: Record<string, unknown> | undefined;
+    reasonCode: string;
+}): Promise<KnowledgeDocumentVersionRecord>;
+export declare function recordKnowledgeLifecycleEvent(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    targetKind: "provider" | "source" | "object";
+    targetId: string;
+    eventType: Extract<KnowledgeLifecycleEventType, "deleted" | "revoked" | "restored">;
+    expectedGeneration: number;
+    reasonCode: string;
+}): Promise<{
+    targetId: string;
+    lifecycleState: KnowledgeLifecycleState;
+    lifecycleGeneration: number;
+    replayed: boolean;
+}>;
+export declare function restoreKnowledgeSourceObject(db: Database, input: Omit<Parameters<typeof recordKnowledgeLifecycleEvent>[1], "targetKind" | "eventType">): Promise<{
+    targetId: string;
+    lifecycleState: KnowledgeLifecycleState;
+    lifecycleGeneration: number;
+    replayed: boolean;
+}>;
+export declare function upsertKnowledgeEntity(db: Database, input: KnowledgeWriteContext & {
+    entityType: string;
+    normalizedKey: string;
+    displayName: string;
+}): Promise<{
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    entityType: string;
+    normalizedKey: string;
+    displayName: string;
+    createdAt: string;
+}>;
+export declare function attachKnowledgeEntityAlias(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    entityId: string;
+    alias: string;
+}): Promise<{
+    id: string;
+    entityId: string;
+    alias: string;
+    normalizedAlias: string;
+}>;
+export declare function upsertKnowledgeFact(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    subjectEntityId: string;
+    predicateKey: string;
+    object: {
+        kind: "entity";
+        entityId: string;
+    } | {
+        kind: Exclude<KnowledgeFactObjectKind, "entity">;
+        value: unknown;
+    };
+}): Promise<KnowledgeFactRecord>;
+export declare function appendKnowledgeClaim(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    factId: string;
+    origin: KnowledgeClaimOrigin;
+    confidenceBps: number;
+    effectiveAt: string;
+    expiresAt?: string | null;
+    extractionMethod: string;
+    extractionMetadata?: Record<string, unknown> | undefined;
+    modelProvider?: string | null;
+    modelName?: string | null;
+    modelVersion?: string | null;
+}): Promise<KnowledgeClaimRecord>;
+export declare function linkKnowledgeClaims(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    relationType: KnowledgeClaimRelationType;
+    fromClaimId: string;
+    toClaimId: string;
+}): Promise<{
+    id: string;
+    relationType: KnowledgeClaimRelationType;
+    fromClaimId: string;
+    toClaimId: string;
+}>;
+export declare function appendKnowledgeClaimEvidence(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    claimId: string;
+    documentVersionId: string;
+    polarity: KnowledgeClaimEvidencePolarity;
+    documentChunkId?: string | null;
+    chunkIndex?: number | null;
+    locator?: string | null;
+    quoteHash?: string | null;
+    contentHash: string;
+}): Promise<{
+    id: string;
+    claimId: string;
+    documentVersionId: string;
+    polarity: KnowledgeClaimEvidencePolarity;
+}>;
+export declare function appendKnowledgeClaimReview(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    claimId: string;
+    state: KnowledgeClaimReviewState;
+    reason: string;
+}): Promise<{
+    id: string;
+    claimId: string;
+    state: KnowledgeClaimReviewState;
+    reviewRevision: number;
+}>;
+export declare function createKnowledgeChangeProposal(db: Database, input: Omit<KnowledgeWriteContext, "scope"> & {
+    claimId: string;
+    evidenceId: string;
+    targetKind: "instruction_policy" | "preference";
+    targetScope: string;
+    targetKey?: string | null;
+    content: string;
+}): Promise<KnowledgeChangeProposalRecord>;
+export declare function listEligibleKnowledgeClaims(db: Database, input: KnowledgeReadContext & {
+    limit?: number | undefined;
+}): Promise<EligibleKnowledgeClaim[]>;
+export declare function getEligibleKnowledgeClaim(db: Database, input: KnowledgeReadContext & {
+    claimId: string;
+}): Promise<EligibleKnowledgeClaim | null>;
+export {};

package/dist/session-queue-commands.d.ts

@@ -1,4 +1,4 @@
-import { ResourceRef, type LatencyMode, type ReasoningEffort, type TurnExecutionPolicyV1 } from "@opengeni/contracts";
+import { ResourceRef, type McpPersonalConnectionDelegation, type LatencyMode, type ReasoningEffort, type TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import type { Database } from "./index";
 import { type SessionCommandActor, type SessionCommandReceiptRow } from "./session-control";
 import * as schema from "./schema";
@@ -158,6 +158,7 @@ export declare function submitHumanPromptInTransaction(db: Database, input: {
     /** Trusted API/core admission snapshot. Omitted only by legacy low-level callers. */
     turnExecutionPolicy?: TurnExecutionPolicyV1;
     source: "user" | "api";
+    personalConnectionDelegations?: McpPersonalConnectionDelegation[];
     mcpCredentialUpdates?: Array<{
         id: string;
         headersEncrypted: Record<string, string>;