@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/acceptance/run-installed-qlever-conformance.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstalledQleverConformance = runInstalledQleverConformance;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const QleverSemanticConformance_1 = require("./QleverSemanticConformance");
+const QleverSearchConformance_1 = require("./QleverSearchConformance");
+const LocalQleverNativeSparqlClient_1 = require("../storage/rdf/LocalQleverNativeSparqlClient");
+function requiredEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+async function runInstalledQleverConformance() {
+    const backend = requiredEnv('XPOD_QLEVER_CONFORMANCE_BACKEND');
+    if (backend !== 'sqlite' && backend !== 'pg') {
+        throw new Error(`XPOD_QLEVER_CONFORMANCE_BACKEND must be sqlite or pg, got ${backend}`);
+    }
+    const fixturePath = requiredEnv('XPOD_QLEVER_SEMANTIC_FIXTURE_PATH');
+    const artifactPath = requiredEnv('XPOD_QLEVER_CONFORMANCE_ARTIFACT_PATH');
+    const timeoutMs = Number(process.env.XPOD_QLEVER_CONFORMANCE_TIMEOUT_MS ?? 60_000);
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new Error('XPOD_QLEVER_CONFORMANCE_TIMEOUT_MS must be a positive integer');
+    }
+    const tempRoot = process.env.XPOD_QLEVER_CONFORMANCE_TEMP_ROOT
+        ?? node_path_1.default.join(node_os_1.default.tmpdir(), `xpod-qlever-installed-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    (0, node_fs_1.mkdirSync)(tempRoot, { recursive: true });
+    let semantic;
+    let search;
+    if (backend === 'sqlite') {
+        const runtimeCommand = (0, LocalQleverNativeSparqlClient_1.resolveLocalQleverRuntimeCommand)();
+        semantic = await (0, QleverSemanticConformance_1.runLocalQleverSemanticConformance)({
+            fixturePath,
+            runtimeCommand,
+            artifactPath: node_path_1.default.join(tempRoot, 'sqlite-semantic.json'),
+            tempRoot: node_path_1.default.join(tempRoot, 'semantic'),
+            timeoutMs,
+        });
+        const searchDatabase = node_path_1.default.join(tempRoot, 'search.sqlite');
+        (0, node_fs_1.rmSync)(searchDatabase, { force: true });
+        search = await (0, QleverSearchConformance_1.runNativeSearchFusionAcceptance)((0, QleverSearchConformance_1.createLocalNativeSearchEngine)(runtimeCommand, searchDatabase));
+    }
+    else {
+        const connectionString = requiredEnv('XPOD_QLEVER_PG_DSN');
+        semantic = await (0, QleverSemanticConformance_1.runPostgresQleverSemanticConformance)({
+            fixturePath,
+            connectionString,
+            artifactPath: node_path_1.default.join(tempRoot, 'pg-semantic.json'),
+            timeoutMs,
+        });
+        search = await (0, QleverSearchConformance_1.runPostgresNativeSearchFusionAcceptance)(connectionString);
+    }
+    if (semantic.status !== 'ok' || semantic.skipped.length !== 0 || semantic.failed.length !== 0) {
+        throw new Error(`${backend} semantic conformance failed: ${JSON.stringify(semantic.failed)}`);
+    }
+    const report = {
+        schemaVersion: 1,
+        backend,
+        status: 'ok',
+        semantic,
+        search,
+    };
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(artifactPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(artifactPath, `${JSON.stringify(report, null, 2)}\n`);
+    return report;
+}
+if (require.main === module) {
+    runInstalledQleverConformance()
+        .then((report) => process.stdout.write(`${JSON.stringify({
+        status: report.status,
+        backend: report.backend,
+        semanticCases: report.semantic.results.length,
+        search: report.search,
+    })}\n`))
+        .catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=run-installed-qlever-conformance.js.map

package/dist/acceptance/run-installed-rdf-conformance.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import type { SemanticConformanceReport } from './RdfSemanticConformance';
+import { type NativeSearchConformanceReport } from './QleverSearchConformance';
+interface InstalledConformanceReport {
+    schemaVersion: 1;
+    backend: 'sqlite' | 'pg-public';
+    status: 'ok';
+    semantic: SemanticConformanceReport;
+    search: NativeSearchConformanceReport;
+}
+export declare function runInstalledRdfConformance(): Promise<InstalledConformanceReport>;
+export {};

package/dist/acceptance/run-installed-rdf-conformance.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstalledRdfConformance = runInstalledRdfConformance;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const QleverSemanticConformance_1 = require("./QleverSemanticConformance");
+const PublicCloudSemanticConformance_1 = require("./PublicCloudSemanticConformance");
+const QleverSearchConformance_1 = require("./QleverSearchConformance");
+const LocalQleverNativeSparqlClient_1 = require("../storage/rdf/LocalQleverNativeSparqlClient");
+function requiredEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+async function runInstalledRdfConformance() {
+    const backend = requiredEnv('XPOD_RDF_CONFORMANCE_BACKEND');
+    if (backend !== 'sqlite' && backend !== 'pg-public') {
+        throw new Error(`XPOD_RDF_CONFORMANCE_BACKEND must be sqlite or pg-public, got ${backend}`);
+    }
+    const fixturePath = requiredEnv('XPOD_QLEVER_SEMANTIC_FIXTURE_PATH');
+    const artifactPath = requiredEnv('XPOD_RDF_CONFORMANCE_ARTIFACT_PATH');
+    const timeoutMs = Number(process.env.XPOD_RDF_CONFORMANCE_TIMEOUT_MS ?? 60_000);
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new Error('XPOD_RDF_CONFORMANCE_TIMEOUT_MS must be a positive integer');
+    }
+    const tempRoot = process.env.XPOD_RDF_CONFORMANCE_TEMP_ROOT
+        ?? node_path_1.default.join(node_os_1.default.tmpdir(), `xpod-rdf-installed-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    (0, node_fs_1.mkdirSync)(tempRoot, { recursive: true });
+    let semantic;
+    let search;
+    if (backend === 'sqlite') {
+        const runtimeCommand = (0, LocalQleverNativeSparqlClient_1.resolveLocalQleverRuntimeCommand)();
+        semantic = await (0, QleverSemanticConformance_1.runLocalQleverSemanticConformance)({
+            fixturePath,
+            runtimeCommand,
+            artifactPath: node_path_1.default.join(tempRoot, 'sqlite-semantic.json'),
+            tempRoot: node_path_1.default.join(tempRoot, 'semantic'),
+            timeoutMs,
+        });
+        const searchDatabase = node_path_1.default.join(tempRoot, 'search.sqlite');
+        (0, node_fs_1.rmSync)(searchDatabase, { force: true });
+        search = await (0, QleverSearchConformance_1.runNativeSearchFusionAcceptance)((0, QleverSearchConformance_1.createLocalNativeSearchEngine)(runtimeCommand, searchDatabase));
+    }
+    else {
+        const connectionString = requiredEnv('XPOD_RDF_PG_DSN');
+        semantic = await (0, PublicCloudSemanticConformance_1.runPostgresPublicSemanticConformance)({
+            fixturePath,
+            connectionString,
+            artifactPath: node_path_1.default.join(tempRoot, 'pg-public-semantic.json'),
+            timeoutMs,
+        });
+        search = await (0, QleverSearchConformance_1.runPostgresPublicSearchFusionAcceptance)(connectionString);
+    }
+    if (semantic.status !== 'ok' || semantic.skipped.length !== 0 || semantic.failed.length !== 0) {
+        throw new Error(`${backend} semantic conformance failed: ${JSON.stringify(semantic.failed)}`);
+    }
+    const report = {
+        schemaVersion: 1,
+        backend,
+        status: 'ok',
+        semantic,
+        search,
+    };
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(artifactPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(artifactPath, `${JSON.stringify(report, null, 2)}\n`);
+    return report;
+}
+if (require.main === module) {
+    runInstalledRdfConformance()
+        .then((report) => process.stdout.write(`${JSON.stringify({
+        status: report.status,
+        backend: report.backend,
+        semanticCases: report.semantic.results.length,
+        search: report.search,
+    })}\n`))
+        .catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=run-installed-rdf-conformance.js.map

package/dist/ai/service/EmbeddingProviderError.d.ts

@@ -0,0 +1,7 @@
+export type EmbeddingProviderFailureCategory = 'embedding_authentication_failed' | 'embedding_authorization_failed' | 'embedding_model_invalid' | 'embedding_request_invalid' | 'embedding_quota_exhausted' | 'embedding_rate_limited' | 'embedding_upstream_unavailable' | 'embedding_provider_failed';
+export interface EmbeddingProviderFailure {
+    retryable: boolean;
+    category: EmbeddingProviderFailureCategory;
+}
+/** Classify AI SDK failures without inspecting provider-specific message text. */
+export declare function classifyEmbeddingProviderFailure(error: unknown): EmbeddingProviderFailure;

package/dist/ai/service/EmbeddingProviderError.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyEmbeddingProviderFailure = classifyEmbeddingProviderFailure;
+const ai_1 = require("ai");
+/** Classify AI SDK failures without inspecting provider-specific message text. */
+function classifyEmbeddingProviderFailure(error) {
+    if (ai_1.RetryError.isInstance(error) && error.lastError !== error) {
+        return classifyEmbeddingProviderFailure(error.lastError);
+    }
+    if (ai_1.NoSuchModelError.isInstance(error)) {
+        return { retryable: false, category: 'embedding_model_invalid' };
+    }
+    if (ai_1.LoadAPIKeyError.isInstance(error)) {
+        return { retryable: false, category: 'embedding_authentication_failed' };
+    }
+    if (ai_1.APICallError.isInstance(error)) {
+        const status = error.statusCode;
+        if (status === 401) {
+            return { retryable: false, category: 'embedding_authentication_failed' };
+        }
+        if (status === 403) {
+            return { retryable: false, category: 'embedding_authorization_failed' };
+        }
+        if (status === 404) {
+            return { retryable: false, category: 'embedding_model_invalid' };
+        }
+        if (status === 402) {
+            return { retryable: true, category: 'embedding_quota_exhausted' };
+        }
+        if (status === 429) {
+            return { retryable: true, category: 'embedding_rate_limited' };
+        }
+        if (error.isRetryable || status === 408 || status === 409 || (status !== undefined && status >= 500)) {
+            return { retryable: true, category: 'embedding_upstream_unavailable' };
+        }
+        if (status !== undefined && status >= 400 && status < 500) {
+            return { retryable: false, category: 'embedding_request_invalid' };
+        }
+    }
+    return { retryable: true, category: 'embedding_provider_failed' };
+}
+//# sourceMappingURL=EmbeddingProviderError.js.map

package/dist/api/ai-gateway/connect/index.js

@@ -2032,8 +2032,11 @@ function parseCredentialRow(row) {
     try {
         return [recordFromCredentialRow(row)];
     }
-    catch {
-        return [];
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid credential row ${stringFrom(row.id) || '<unknown>'}: ${detail}`, {
+            cause: error,
+        });
     }
 }
 function versionFromRow(row) {

package/dist/api/auth/AuthContext.d.ts

@@ -45,6 +45,11 @@ export interface ServiceAuthContext {
 }
 export type AuthContext = SolidAuthContext | NodeAuthContext | ServiceAuthContext;
 export declare function isSolidAuth(ctx: AuthContext): ctx is SolidAuthContext;
+export declare function hasSolidClientCredentialsAuthority(ctx: AuthContext | undefined): ctx is SolidAuthContext & {
+    clientId: string;
+    clientSecret: string;
+    viaApiKey: true;
+};
 export declare function isNodeAuth(ctx: AuthContext): ctx is NodeAuthContext;
 /**
  * Get webId from auth context

package/dist/api/auth/AuthContext.js

@@ -10,6 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSolidAuth = isSolidAuth;
+exports.hasSolidClientCredentialsAuthority = hasSolidClientCredentialsAuthority;
 exports.isNodeAuth = isNodeAuth;
 exports.getWebId = getWebId;
 exports.getDisplayName = getDisplayName;
@@ -20,6 +21,15 @@ exports.hasScope = hasScope;
 function isSolidAuth(ctx) {
     return ctx.type === 'solid';
 }
+function hasSolidClientCredentialsAuthority(ctx) {
+    return ctx?.type === 'solid'
+        && ctx.viaApiKey === true
+        && typeof ctx.clientId === 'string'
+        && ctx.clientId.length > 0
+        && typeof ctx.clientSecret === 'string'
+        && ctx.clientSecret.length > 0
+        && ctx.webId.length > 0;
+}
 function isNodeAuth(ctx) {
     return ctx.type === 'node';
 }

package/dist/api/container/common.js

@@ -48,6 +48,8 @@ const VercelChatService_1 = require("../service/VercelChatService");
 const provider_http_transport_1 = require("../service/provider-http-transport");
 const VectorService_1 = require("../service/VectorService");
 const RdfStorageStatsService_1 = require("../service/RdfStorageStatsService");
+const RdfSearchReconciliationRepository_1 = require("../../search/RdfSearchReconciliationRepository");
+const RdfSearchReconciliationWorker_1 = require("../service/RdfSearchReconciliationWorker");
 const ApiServer_1 = require("../ApiServer");
 const chatkit_1 = require("../chatkit");
 const matrix_1 = require("../matrix");
@@ -553,6 +555,22 @@ function registerCommonServices(container) {
         rdfSearchIndexingService: (0, awilix_1.asFunction)(({ rdfEngine, chatKitStore, embeddingService }) => {
             return (0, rdf_1.createApiRdfSearchIndexingService)(rdfEngine, { chatKitStore, embeddingService });
         }).singleton(),
+        rdfSearchReconciliationRepository: (0, awilix_1.asFunction)(({ db }) => {
+            return new RdfSearchReconciliationRepository_1.RdfSearchReconciliationRepository(db);
+        }).singleton(),
+        rdfSearchReconciliationWorker: (0, awilix_1.asFunction)(({ rdfSearchReconciliationRepository, rdfSearchIndexingService, runAuthContextRegistry, chatKitStore, rdfEngine, }) => {
+            const logger = (0, global_logger_factory_1.getLoggerFor)('RdfSearchReconciliationWorker');
+            return new RdfSearchReconciliationWorker_1.RdfSearchReconciliationWorker({
+                repository: rdfSearchReconciliationRepository,
+                indexingService: rdfSearchIndexingService,
+                contextRegistry: runAuthContextRegistry,
+                store: chatKitStore,
+                rdfEngine,
+                onError: (error, input) => {
+                    logger.error(`Failed RDF search ${input.phase} for ${input.sourceUri ?? input.sourceKey ?? 'unknown source'}: ${error}`);
+                },
+            });
+        }).singleton(),
         rdfStorageStatsService: (0, awilix_1.asFunction)(({ config, rdfEngine }) => {
             return new RdfStorageStatsService_1.RdfStorageStatsService({
                 edition: config.edition,
@@ -560,7 +578,7 @@ function registerCommonServices(container) {
                 rdfEngine,
             });
         }).singleton(),
-        runExecutionBackend: (0, awilix_1.asFunction)(({ config, inngestRuntimeConfig, chatKitStore, taskAuthBindingService, runAuthContextRegistry, runContextRetriever, rdfSearchIndexingService, aiConnectionInvocationKeyIssuer }) => {
+        runExecutionBackend: (0, awilix_1.asFunction)(({ config, inngestRuntimeConfig, chatKitStore, taskAuthBindingService, runAuthContextRegistry, runContextRetriever, rdfSearchIndexingService, rdfSearchReconciliationRepository, aiConnectionInvocationKeyIssuer }) => {
             return new InngestRunExecutionBackend_1.InngestRunExecutionBackend({
                 baseUrl: inngestRuntimeConfig?.baseUrl,
                 eventKey: inngestRuntimeConfig?.eventKey,
@@ -582,6 +600,7 @@ function registerCommonServices(container) {
                     agentLoopIsolation: config.edition === 'cloud' ? 'sandboxed-process' : 'in-process',
                     requireSandbox: config.edition === 'cloud',
                     rdfSearchIndexingService,
+                    rdfSearchReconciliationRepository,
                 }),
             });
         }).singleton(),

package/dist/api/container/rdf.d.ts

@@ -13,3 +13,4 @@ export declare function createApiRdfEngine(config: ApiContainerConfig): RdfEngin
 export declare function createApiRunContextRetriever(rdfEngine: RdfEngineLike | undefined, dependencies?: ApiRunContextRetrieverDependencies): RunContextRetriever<StoreContext> | undefined;
 export declare function createApiRdfSearchIndexingService(rdfEngine: RdfEngineLike | undefined, dependencies?: ApiRunContextRetrieverDependencies): RdfSearchIndexingService | undefined;
 export declare function isPostgresConnectionString(value: string): boolean;
+export declare function isSqliteConnectionString(value: string): boolean;

package/dist/api/container/rdf.js

@@ -4,27 +4,48 @@ exports.createApiRdfEngine = createApiRdfEngine;
 exports.createApiRunContextRetriever = createApiRunContextRetriever;
 exports.createApiRdfSearchIndexingService = createApiRdfSearchIndexingService;
 exports.isPostgresConnectionString = isPostgresConnectionString;
+exports.isSqliteConnectionString = isSqliteConnectionString;
 const RdfRunContextRetriever_1 = require("../runs/RdfRunContextRetriever");
 const rdf_1 = require("../../storage/rdf");
+const AuthContext_1 = require("../auth/AuthContext");
 const RdfSearchIndexingService_1 = require("../service/RdfSearchIndexingService");
 function createApiRdfEngine(config) {
-    const connectionString = config.sparqlEndpoint;
-    if (config.edition !== 'cloud' || !connectionString || !isPostgresConnectionString(connectionString)) {
+    const connectionString = config.edition === 'local' && config.rdfIndexPath
+        ? `sqlite:${config.rdfIndexPath}`
+        : config.sparqlEndpoint;
+    if (!connectionString)
+        return undefined;
+    if (isSqliteConnectionString(connectionString)) {
+        const path = sqlitePathFromConnectionString(connectionString);
+        return new rdf_1.SolidRdfEngine({
+            index: { path },
+            textIndex: { path },
+            vectorIndex: { path },
+            nativeSparqlClient: new rdf_1.LocalQleverNativeSparqlClient({
+                args: [
+                    '--sqlite-path',
+                    path,
+                ],
+            }),
+        });
+    }
+    if (!isPostgresConnectionString(connectionString)) {
         return undefined;
     }
     return new rdf_1.PostgresRdfEngine({
         driver: 'pg',
         connectionString,
         rdfAccelerationProfile: 'pg-hot-operators',
-        nativeSparqlEnabled: config.rdfNativeSparqlEnabled,
         maintenanceIntervalMs: 0,
         textIndex: {
             driver: 'pg',
             connectionString,
+            textSearchBackend: 'pg-native-fts',
         },
         vectorIndex: {
             driver: 'pg',
             connectionString,
+            backend: 'component',
         },
     });
 }
@@ -57,7 +78,15 @@ function createRunContextEmbeddingProvider(dependencies) {
         return undefined;
     }
     return async (input) => {
-        const config = await chatKitStore.getAiConfig(input.context);
+        const auth = input.context.auth;
+        if (!(0, AuthContext_1.hasSolidClientCredentialsAuthority)(auth)) {
+            return undefined;
+        }
+        const config = await chatKitStore.getAiConfig({
+            ...input.context,
+            userId: auth.webId,
+            auth,
+        });
         if (!config?.embeddingModel || !config.apiKey) {
             return undefined;
         }
@@ -68,13 +97,23 @@ function createRunContextEmbeddingProvider(dependencies) {
                 baseUrl: config.baseUrl,
                 proxyUrl: config.proxyUrl,
             }, config.embeddingModel),
+            provider: config.providerId,
             model: config.embeddingModel,
+            modelVersion: (0, RdfSearchIndexingService_1.normalizeRdfVectorModelVersion)(config.embeddingModelVersion),
+            inputKind: 'semantic',
+            projectionPolicyVersion: RdfSearchIndexingService_1.DEFAULT_RDF_VECTOR_PROJECTION_POLICY_VERSION,
         };
     };
 }
 function isPostgresConnectionString(value) {
     return value.startsWith('postgres://') || value.startsWith('postgresql://');
 }
+function isSqliteConnectionString(value) {
+    return value.startsWith('sqlite:');
+}
+function sqlitePathFromConnectionString(value) {
+    return value.slice('sqlite:'.length);
+}
 function contextRdfAccessScope(context) {
     const candidate = context.rdfAccessScope;
     if (!candidate || typeof candidate !== 'object') {

package/dist/api/container/types.d.ts

@@ -28,6 +28,8 @@ import type { RuntimeHost } from '../../runtime/host/types';
 import type { ProviderRegistry, EmbeddingService } from '../../ai/service';
 import type { VectorService } from '../service/VectorService';
 import type { RdfSearchIndexingService } from '../service/RdfSearchIndexingService';
+import type { RdfSearchReconciliationRepository } from '../../search/RdfSearchReconciliationRepository';
+import type { RdfSearchReconciliationWorker } from '../service/RdfSearchReconciliationWorker';
 import type { RdfStorageStatsService } from '../service/RdfStorageStatsService';
 import type { InngestRunExecutionBackend } from '../runs/InngestRunExecutionBackend';
 import type { RunContextRetriever } from '../runs/RunExecutionBackend';
@@ -225,6 +227,8 @@ export interface ApiContainerCradle {
     rdfEngine: RdfEngineLike | undefined;
     runContextRetriever: RunContextRetriever<StoreContext> | undefined;
     rdfSearchIndexingService: RdfSearchIndexingService | undefined;
+    rdfSearchReconciliationRepository: RdfSearchReconciliationRepository;
+    rdfSearchReconciliationWorker: RdfSearchReconciliationWorker;
     runExecutionBackend: InngestRunExecutionBackend;
     taskAuthBindingService: TaskAuthBindingService<StoreContext>;
     taskService: TaskService<StoreContext>;

package/dist/api/runs/InngestRunExecutionBackend.d.ts

@@ -161,7 +161,7 @@ export declare class InngestRunExecutionBackend implements RunExecutionBackend {
         readonly event: string;
     }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
         logger: import("inngest").Logger;
-    }, "group" | "requestId" | "event" | "attempt" | "events" | "runId" | "step" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+    }, "group" | "step" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
         step: {
             sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
             waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
@@ -342,7 +342,7 @@ export declare class InngestRunExecutionBackend implements RunExecutionBackend {
         readonly event: string;
     }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
         logger: import("inngest").Logger;
-    }, "group" | "requestId" | "event" | "attempt" | "events" | "runId" | "step" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+    }, "group" | "step" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
         step: {
             sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
             waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {

package/dist/api/runs/PiAgentRuntimeDriver.d.ts

@@ -1,5 +1,6 @@
 import { type SolidFS, type SolidFsProjection } from '../../solidfs';
 import type { RdfSearchIndexingService } from '../service/RdfSearchIndexingService';
+import type { RdfSearchReconciliationRepository } from '../../search/RdfSearchReconciliationRepository';
 import type { AgentRuntimeEvent } from './AgentRuntimeTypes';
 import type { RunExecutionBackend, RunExecutionInput } from './RunExecutionBackend';
 type PiSdk = typeof import('@mariozechner/pi-coding-agent');
@@ -28,6 +29,7 @@ export interface PiAgentRuntimeDriverOptions {
     solidfsProjection?: SolidFsProjection;
     solidfsJournalRootDir?: string;
     rdfSearchIndexingService?: RdfSearchIndexingService;
+    rdfSearchReconciliationRepository?: Pick<RdfSearchReconciliationRepository, 'upsertRetryable' | 'upsertBlockedConfig' | 'waitForConfig' | 'upsertApplied' | 'deleteSource'>;
 }
 /**
  * Request-scoped adapter around pi's AgentSession primitives.

package/dist/api/runs/PiAgentRuntimeDriver.js

@@ -59,6 +59,7 @@ class PiAgentRuntimeDriver {
         if (this.options.rdfSearchIndexingService) {
             syncers.push(new RdfSearchIndexingSolidFsSyncer_1.RdfSearchIndexingSolidFsSyncer({
                 service: this.options.rdfSearchIndexingService,
+                reconciliationRepository: this.options.rdfSearchReconciliationRepository,
             }));
         }
         return syncers.length === 1

package/dist/api/runs/RdfRunContextRetriever.d.ts

@@ -4,7 +4,11 @@ import type { RdfEngineLike, RdfQuery, RdfQueryCacheScope } from '../../storage/
 import type { RunContextRetrievalInput, RunContextRetriever, RunRetrievedContext } from './RunExecutionBackend';
 export type RdfRunContextEmbedding = number[] | {
     embedding: number[];
+    provider?: string;
     model?: string;
+    modelVersion?: string;
+    inputKind?: string;
+    projectionPolicyVersion?: string;
 };
 export interface RdfRunContextRetrieverOptions<TContext = StoreContext> {
     rdfEngine: RdfEngineLike;
@@ -18,7 +22,11 @@ export interface RdfRunContextRetrieverOptions<TContext = StoreContext> {
     failOpen?: boolean;
     textWeight?: number;
     vectorWeight?: number;
+    vectorProvider?: string;
     vectorModel?: string;
+    vectorModelVersion?: string;
+    vectorInputKind?: string;
+    vectorProjectionPolicyVersion?: string;
     sourcePrefix?: string | ((input: RunContextRetrievalInput<TContext>) => string | undefined);
     cacheScope?: RdfQueryCacheScope | ((input: RunContextRetrievalInput<TContext>) => RdfQueryCacheScope | undefined);
     accessScope?: RdfAccessScope | ((input: RunContextRetrievalInput<TContext>) => RdfAccessScope | undefined);

package/dist/api/runs/RdfRunContextRetriever.js

@@ -98,16 +98,26 @@ class RdfRunContextRetriever {
             query.vectorSearch = [
                 {
                     embedding: normalizedEmbedding.embedding,
+                    vectorProvider: normalizedEmbedding.provider ?? this.options.vectorProvider,
                     vectorModel: normalizedEmbedding.model ?? this.options.vectorModel,
+                    vectorModelVersion: normalizedEmbedding.modelVersion ?? this.options.vectorModelVersion,
+                    vectorInputKind: normalizedEmbedding.inputKind ?? this.options.vectorInputKind,
+                    vectorProjectionPolicyVersion: normalizedEmbedding.projectionPolicyVersion ?? this.options.vectorProjectionPolicyVersion,
                     scope,
                     limit,
-                    source: 'source',
+                    source: 'vectorSource',
                     chunk: 'vectorChunk',
                     content: 'vectorContent',
                     heading: 'vectorHeading',
                     score: 'vectorScore',
                     distance: 'vectorDistance',
+                    sourceKey: 'sourceKey',
+                    retrievalPoint: 'retrievalPointKey',
+                    provider: 'vectorProvider',
                     model: 'vectorModel',
+                    modelVersion: 'vectorModelVersion',
+                    inputKind: 'vectorInputKind',
+                    projectionPolicyVersion: 'vectorProjectionPolicyVersion',
                 },
             ];
             query.binds = [
@@ -141,7 +151,11 @@ class RdfRunContextRetriever {
                 'vectorHeading',
                 'vectorScore',
                 'vectorDistance',
+                'vectorProvider',
                 'vectorModel',
+                'vectorModelVersion',
+                'vectorInputKind',
+                'vectorProjectionPolicyVersion',
                 'fusionScore',
             ];
             query.orderBy = [
@@ -200,7 +214,11 @@ class RdfRunContextRetriever {
         const vectorScore = termNumber(row.vectorScore);
         const heading = termValue(row.textHeading) || termValue(row.vectorHeading);
         const vectorDistance = termNumber(row.vectorDistance);
+        const vectorProvider = termValue(row.vectorProvider);
         const vectorModel = termValue(row.vectorModel);
+        const vectorModelVersion = termValue(row.vectorModelVersion);
+        const vectorInputKind = termValue(row.vectorInputKind);
+        const vectorProjectionPolicyVersion = termValue(row.vectorProjectionPolicyVersion);
         const entityProvenance = parseJsonArray(termValue(row.entityProvenance));
         const metadata = compactRecord({
             untrustedContext: true,
@@ -213,7 +231,11 @@ class RdfRunContextRetriever {
             textScore,
             vectorScore,
             vectorDistance,
+            vectorProvider,
             vectorModel,
+            vectorModelVersion,
+            vectorInputKind,
+            vectorProjectionPolicyVersion,
             contentType: termValue(row.contentType),
         });
         return {

package/dist/api/runtime.js

@@ -452,12 +452,26 @@ async function startApiService(options = {}) {
             authMiddleware: (0, awilix_1.asValue)(new OpenAuthMiddleware_1.OpenAuthMiddleware({ context: options.authContext })),
         });
     }
-    (0, routes_1.registerRoutes)(container);
-    await registerPrimaryServiceToken(container, config, logger);
-    await reconcileLocalOwnerRoles(container, config, logger);
-    await startBackgroundServices(container, logger);
-    const server = container.resolve('apiServer');
-    await server.start();
+    let server;
+    let backgroundServicesStarted = false;
+    try {
+        (0, routes_1.registerRoutes)(container);
+        server = container.resolve('apiServer');
+        await container.resolve('rdfEngine', { allowUnregistered: true })?.open?.();
+        await registerPrimaryServiceToken(container, config, logger);
+        await reconcileLocalOwnerRoles(container, config, logger);
+        await startBackgroundServices(container, logger);
+        backgroundServicesStarted = true;
+        await server.start();
+    }
+    catch (error) {
+        if (backgroundServicesStarted) {
+            await stopBackgroundServices(container);
+        }
+        await stopApiRuntimeServices(container);
+        await embeddedInngest.service.stop().catch(() => undefined);
+        throw error;
+    }
     logger.info(`API Service active on ${config.socketPath ? `unix://${config.socketPath}` : `${config.host}:${config.port}`}`);
     return {
         config,