@botbotgo/agent-harness 0.0.154 → 0.0.155

package/dist/runtime/harness.js

@@ -21,16 +21,17 @@ import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harn
 import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
 import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
-import { resolveStoreFromConfig, } from "./harness/run/resources.js";
+import { resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
 import { closeMcpClientsForWorkspace } from "../resource/mcp-tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
-import { Mem0IngestionSync, readMem0RuntimeConfig } from "./harness/system/mem0-ingestion-sync.js";
+import { Mem0IngestionSync, Mem0SemanticRecall, readMem0RuntimeConfig, } from "./harness/system/mem0-ingestion-sync.js";
+import { createRuntimeMemoryManager, RuntimeMemoryFormationSync, readRuntimeMemoryFormationConfig, } from "./harness/system/runtime-memory-manager.js";
 import { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.js";
-import { listMemoryRecordsForScopes, persistStructuredMemoryRecords, } from "./harness/system/runtime-memory-records.js";
+import { getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, } from "./harness/system/runtime-memory-records.js";
 import { consolidateStructuredMemoryScope } from "./harness/system/runtime-memory-consolidation.js";
 import { normalizeLangMemMemoryKind, readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
@@ -70,6 +71,11 @@ export class AgentHarnessRuntime {
     unregisterRuntimeMemorySync;
     mem0IngestionSync;
     unregisterMem0IngestionSync;
+    mem0SemanticRecall;
+    runtimeMemoryFormationConfig;
+    runtimeMemoryManager;
+    runtimeMemoryFormationSync;
+    unregisterRuntimeMemoryFormationSync;
     resolvedRuntimeAdapterOptions;
     healthMonitor;
     recoveryConfig;
@@ -84,6 +90,19 @@ export class AgentHarnessRuntime {
     closed = false;
     backgroundEventRuntime;
     runtimeEventOperations;
+    async resolveRuntimeMemoryVectorStore() {
+        const vectorStoreConfig = typeof this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.vectorStore === "object" &&
+            this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.vectorStore
+            ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.vectorStore
+            : undefined;
+        const vectorStoreRef = typeof vectorStoreConfig?.ref === "string" && vectorStoreConfig.ref.trim().length > 0 ? vectorStoreConfig.ref : undefined;
+        try {
+            return await resolveVectorStore(this.workspace, this.vectorStores, vectorStoreRef, this.resolvedRuntimeAdapterOptions);
+        }
+        catch {
+            return null;
+        }
+    }
     defaultRunRoot() {
         return this.defaultRunRootValue;
     }
@@ -185,10 +204,40 @@ export class AgentHarnessRuntime {
         if (mem0RuntimeConfig) {
             this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runRoot);
             this.unregisterMem0IngestionSync = this.eventBus.registerProjection(this.mem0IngestionSync);
+            this.mem0SemanticRecall = new Mem0SemanticRecall(mem0RuntimeConfig);
         }
         else {
             this.mem0IngestionSync = null;
             this.unregisterMem0IngestionSync = () => { };
+            this.mem0SemanticRecall = null;
+        }
+        const runtimeMemoryFormationConfig = readRuntimeMemoryFormationConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot);
+        this.runtimeMemoryFormationConfig = runtimeMemoryFormationConfig ?? null;
+        this.runtimeMemoryManager =
+            this.defaultRuntimeEntryBinding && runtimeMemoryFormationConfig
+                ? createRuntimeMemoryManager({
+                    workspace: this.workspace,
+                    binding: this.defaultRuntimeEntryBinding,
+                    config: runtimeMemoryFormationConfig,
+                    modelResolver: this.resolvedRuntimeAdapterOptions.modelResolver,
+                })
+                : null;
+        if (runtimeMemoryFormationConfig) {
+            this.runtimeMemoryFormationSync = new RuntimeMemoryFormationSync(this.persistence, runtimeMemoryFormationConfig, (input) => this.persistStructuredMemoryCandidates(this.defaultRuntimeEntryBinding, {
+                candidates: input.candidates,
+                threadId: input.threadId,
+                runId: input.runId,
+                agentId: input.agentId,
+                userId: input.userId,
+                projectId: input.projectId,
+                recordedAt: input.recordedAt,
+                storeCandidateLog: false,
+            }).then(() => undefined), runRoot);
+            this.unregisterRuntimeMemoryFormationSync = this.eventBus.registerProjection(this.runtimeMemoryFormationSync);
+        }
+        else {
+            this.runtimeMemoryFormationSync = null;
+            this.unregisterRuntimeMemoryFormationSync = () => { };
         }
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
@@ -294,23 +343,20 @@ export class AgentHarnessRuntime {
             ? input.topK
             : (this.runtimeMemoryPolicy?.retrieval.defaultTopK ?? 5);
         const kinds = input.kinds?.length ? new Set(input.kinds) : null;
-        const items = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, scopes))
-            .filter((record) => this.matchesRecallScope(record, {
-            threadId: input.threadId,
-            agentId,
-            workspaceId: input.workspaceId ?? workspaceId,
-            userId,
-            projectId,
-        }))
-            .filter((record) => (input.includeStale ? record.status === "active" || record.status === "stale" : record.status === "active"))
-            .filter((record) => (kinds ? kinds.has(record.kind) : true))
-            .map((record) => ({
-            record,
-            score: scoreMemoryText(input.query.trim(), `${record.summary}\n${record.content}`, this.getMemoryScopeBoost(record.scope)) +
-                Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365))) +
-                record.confidence,
+        const items = (await this.rankRecallCandidates(binding, {
+            query: input.query.trim(),
+            scopes,
+            kinds,
+            topK,
+            includeStale: input.includeStale === true,
+            filters: {
+                threadId: input.threadId,
+                agentId,
+                workspaceId: input.workspaceId ?? workspaceId,
+                userId,
+                projectId,
+            },
         }))
-            .sort((left, right) => right.score - left.score)
             .slice(0, topK)
             .map(({ record }) => record);
         return { items };
@@ -518,36 +564,236 @@ export class AgentHarnessRuntime {
         }
         return 0;
     }
-    async buildRuntimeMemoryContext(binding, threadId, input) {
-        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
-        const ranked = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace"]))
-            .filter((record) => {
-            if (record.status !== "active") {
-                return false;
+    memoryFreshnessBoost(value) {
+        return Math.max(0, 1 - ((Date.now() - Date.parse(value)) / (1000 * 60 * 60 * 24 * 365)));
+    }
+    scoreStructuredRecord(query, record) {
+        return (scoreMemoryText(query, `${record.summary}\n${record.content}`, this.getMemoryScopeBoost(record.scope)) +
+            this.memoryFreshnessBoost(record.lastConfirmedAt) +
+            record.confidence);
+    }
+    normalizeMemoryDedupKey(record) {
+        return `${record.scope}::${record.summary.toLowerCase().replace(/\s+/g, " ").trim()}::${record.content.toLowerCase().replace(/\s+/g, " ").trim()}`;
+    }
+    inferMem0MemoryKind(hit) {
+        const candidates = [
+            ...hit.categories,
+            typeof hit.metadata.kind === "string" ? hit.metadata.kind : undefined,
+            typeof hit.metadata.memoryType === "string" ? hit.metadata.memoryType : undefined,
+        ].filter((value) => typeof value === "string" && value.trim().length > 0);
+        for (const candidate of candidates) {
+            const kind = normalizeLangMemMemoryKind(candidate);
+            if (kind === "semantic" || kind === "episodic" || kind === "procedural") {
+                return kind;
             }
-            if (record.scope === "thread") {
-                return String(record.provenance.threadId ?? "") === threadId;
+        }
+        return "semantic";
+    }
+    inferMem0MemoryScope(hit, filters) {
+        const metadataScope = typeof hit.metadata.scope === "string" ? hit.metadata.scope : undefined;
+        if (metadataScope === "thread" || metadataScope === "agent" || metadataScope === "workspace" || metadataScope === "user" || metadataScope === "project") {
+            return metadataScope;
+        }
+        if (typeof hit.metadata.threadId === "string" && filters.threadId && hit.metadata.threadId === filters.threadId) {
+            return "thread";
+        }
+        if (hit.agentId === filters.agentId || hit.metadata.agentId === filters.agentId) {
+            return "agent";
+        }
+        return "workspace";
+    }
+    createMem0MemoryRecord(hit, filters) {
+        const scope = this.inferMem0MemoryScope(hit, filters);
+        const kind = this.inferMem0MemoryKind(hit);
+        const summary = hit.memory.split("\n")[0]?.trim() || hit.memory;
+        return {
+            id: `mem0:${hit.id}`,
+            canonicalKey: `mem0:${hit.id}`,
+            kind,
+            scope,
+            content: hit.memory,
+            summary: summary.slice(0, 240),
+            status: "active",
+            confidence: Math.max(0, Math.min(1, hit.score || 0.5)),
+            createdAt: hit.createdAt,
+            observedAt: hit.createdAt,
+            lastConfirmedAt: hit.updatedAt,
+            sourceType: "mem0-search",
+            sourceRefs: [`mem0:${hit.id}`],
+            tags: hit.categories,
+            provenance: {
+                source: "mem0",
+                threadId: typeof hit.metadata.threadId === "string" ? hit.metadata.threadId : filters.threadId,
+                runId: hit.runId ?? (typeof hit.metadata.runId === "string" ? hit.metadata.runId : undefined),
+                agentId: hit.agentId ?? (typeof hit.metadata.agentId === "string" ? hit.metadata.agentId : filters.agentId),
+                workspaceId: filters.workspaceId,
+                userId: filters.userId,
+                projectId: filters.projectId,
+                ...hit.metadata,
+            },
+            revision: 1,
+            supersedes: [],
+            conflictsWith: [],
+        };
+    }
+    async rankRecallCandidates(binding, input) {
+        const structuredRecords = await listMemoryRecordsForScopes(this.runtimeMemoryStore, input.scopes);
+        const ranked = structuredRecords
+            .filter((record) => this.matchesRecallScope(record, input.filters))
+            .filter((record) => (input.includeStale ? record.status === "active" || record.status === "stale" : record.status === "active"))
+            .filter((record) => (input.kinds ? input.kinds.has(record.kind) : true))
+            .map((record) => ({
+            record,
+            score: this.scoreStructuredRecord(input.query, record),
+        }));
+        const deduped = new Map();
+        for (const item of ranked) {
+            deduped.set(this.normalizeMemoryDedupKey(item.record), item);
+        }
+        const vectorStore = await this.resolveRuntimeMemoryVectorStore();
+        if (vectorStore) {
+            try {
+                const vectorHits = await vectorStore.similaritySearch(input.query, Math.max(input.topK, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? input.topK));
+                for (const hit of vectorHits) {
+                    const metadata = typeof hit.metadata === "object" && hit.metadata && !Array.isArray(hit.metadata)
+                        ? hit.metadata
+                        : {};
+                    const recordId = typeof metadata.recordId === "string" ? metadata.recordId : undefined;
+                    const scope = metadata.scope;
+                    if (!recordId || (scope !== "thread" && scope !== "agent" && scope !== "workspace" && scope !== "user" && scope !== "project")) {
+                        continue;
+                    }
+                    const canonical = await getMemoryRecord(this.runtimeMemoryStore, scope, recordId);
+                    if (!canonical) {
+                        continue;
+                    }
+                    if (!this.matchesRecallScope(canonical, input.filters)) {
+                        continue;
+                    }
+                    if (input.includeStale ? canonical.status !== "active" && canonical.status !== "stale" : canonical.status !== "active") {
+                        continue;
+                    }
+                    if (input.kinds && !input.kinds.has(canonical.kind)) {
+                        continue;
+                    }
+                    const key = this.normalizeMemoryDedupKey(canonical);
+                    const score = this.scoreStructuredRecord(input.query, canonical) + (typeof hit.score === "number" ? hit.score : 0);
+                    const existing = deduped.get(key);
+                    if (!existing || score > existing.score) {
+                        deduped.set(key, { record: canonical, score });
+                    }
+                }
             }
-            if (record.scope === "agent") {
-                return String(record.provenance.agentId ?? "") === binding.agent.id;
+            catch {
+                // Fail open to lexical/runtime ranking.
             }
-            return true;
-        })
+        }
+        const supportsMem0Scope = input.scopes.some((scope) => scope === "thread" || scope === "agent" || scope === "workspace");
+        if (!this.mem0SemanticRecall || !supportsMem0Scope) {
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+        try {
+            const hits = await this.mem0SemanticRecall.search({
+                query: input.query,
+                topK: Math.max(input.topK, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? input.topK),
+                agentId: input.filters.agentId,
+                threadId: input.filters.threadId,
+            });
+            for (const hit of hits) {
+                const record = this.createMem0MemoryRecord(hit, input.filters);
+                if (!input.scopes.includes(record.scope)) {
+                    continue;
+                }
+                if (input.kinds && !input.kinds.has(record.kind)) {
+                    continue;
+                }
+                const key = this.normalizeMemoryDedupKey(record);
+                if (deduped.has(key)) {
+                    continue;
+                }
+                deduped.set(key, {
+                    record,
+                    score: this.scoreStructuredRecord(input.query, record) + Math.max(0, Math.min(1, hit.score)) * 4,
+                });
+            }
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+        catch {
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+    }
+    async rebuildRuntimeMemoryVectorIndex() {
+        const vectorStore = await this.resolveRuntimeMemoryVectorStore();
+        if (!vectorStore) {
+            return;
+        }
+        const records = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace", "user", "project"]))
+            .filter((record) => record.status === "active");
+        try {
+            await vectorStore.delete({ deleteAll: true });
+            if (records.length === 0) {
+                return;
+            }
+            await vectorStore.addDocuments(records.map((record) => ({
+                pageContent: `${record.summary}\n${record.content}`,
+                metadata: {
+                    recordId: record.id,
+                    scope: record.scope,
+                    kind: record.kind,
+                    status: record.status,
+                    threadId: record.provenance.threadId,
+                    agentId: record.provenance.agentId,
+                    workspaceId: record.provenance.workspaceId,
+                    userId: record.provenance.userId,
+                    projectId: record.provenance.projectId,
+                    confidence: record.confidence,
+                    lastConfirmedAt: record.lastConfirmedAt,
+                },
+            })));
+        }
+        catch {
+            // Fail open: vector indexing must not break durable memory writes.
+        }
+    }
+    async buildRuntimeMemoryContext(binding, threadId, input) {
+        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
+        const workspaceId = this.getWorkspaceId(binding);
+        const ranked = (await this.rankRecallCandidates(binding, {
+            query,
+            scopes: ["thread", "agent", "workspace", "user", "project"],
+            kinds: null,
+            topK: this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8,
+            includeStale: false,
+            filters: {
+                threadId,
+                agentId: binding.agent.id,
+                workspaceId,
+                userId: "default",
+                projectId: workspaceId,
+            },
+        }))
             .map((record) => {
-            const scopeBoost = record.scope === "thread" ? 4 : record.scope === "agent" ? 2 : 1;
-            const freshnessBoost = Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365)));
+            const scopeBoost = record.record.scope === "thread"
+                ? 4
+                : record.record.scope === "agent"
+                    ? 3
+                    : record.record.scope === "user"
+                        ? 2
+                        : 1;
             return {
                 content: [
-                    `# Durable ${record.scope[0].toUpperCase()}${record.scope.slice(1)} Memory`,
+                    `# Durable ${record.record.scope[0].toUpperCase()}${record.record.scope.slice(1)} Memory`,
                     "",
-                    `- summary: ${record.summary}`,
-                    `- kind: ${record.kind}`,
-                    `- scope: ${record.scope}`,
-                    `- confidence: ${record.confidence.toFixed(2)}`,
+                    `- summary: ${record.record.summary}`,
+                    `- kind: ${record.record.kind}`,
+                    `- scope: ${record.record.scope}`,
+                    `- confidence: ${record.record.confidence.toFixed(2)}`,
                     "",
-                    record.content,
+                    record.record.content,
                 ].join("\n"),
-                score: scoreMemoryText(query, `${record.summary}\n${record.content}`, scopeBoost) + freshnessBoost + record.confidence,
+                score: scoreMemoryText(query, `${record.record.summary}\n${record.record.content}`, scopeBoost) +
+                    this.memoryFreshnessBoost(record.record.lastConfirmedAt) +
+                    record.record.confidence,
             };
         })
             .sort((left, right) => right.score - left.score)
@@ -561,6 +807,9 @@ export class AgentHarnessRuntime {
         if (!Array.isArray(value) || value.length === 0) {
             return;
         }
+        if (this.runtimeMemoryFormationConfig?.hotPath.enabled === false) {
+            return;
+        }
         const candidates = value
             .filter((candidate) => typeof candidate === "object" && candidate !== null)
             .filter((candidate) => candidate.noStore !== true && typeof candidate.content === "string" && candidate.content.trim().length > 0);
@@ -580,20 +829,33 @@ export class AgentHarnessRuntime {
         const workspaceId = this.getWorkspaceId(binding);
         const userId = input.userId ?? "default";
         const projectId = input.projectId ?? workspaceId;
-        const threadCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
-        const workspaceCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
-        const agentCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        const existingRecords = await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace", "user", "project"]);
+        const transformedCandidates = this.runtimeMemoryManager
+            ? await this.runtimeMemoryManager.transform({
+                candidates: input.candidates,
+                binding,
+                threadId: input.threadId,
+                runId: input.runId,
+                recordedAt: input.recordedAt,
+                existingRecords,
+            })
+            : input.candidates;
+        const threadCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
+        const workspaceCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
+        const agentCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        const userCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "user");
+        const projectCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "project");
         if (input.storeCandidateLog) {
             await this.runtimeMemoryStore.put(["memories", "candidates", input.threadId], `${input.runId}.json`, {
                 runId: input.runId,
                 threadId: input.threadId,
                 storedAt: input.recordedAt,
-                candidates: input.candidates,
+                candidates: transformedCandidates,
             });
         }
         const persisted = await persistStructuredMemoryRecords({
             store: this.runtimeMemoryStore,
-            candidates: input.candidates,
+            candidates: transformedCandidates,
             threadId: input.threadId,
             runId: input.runId,
             agentId: input.agentId,
@@ -602,6 +864,7 @@ export class AgentHarnessRuntime {
             projectId,
             recordedAt: input.recordedAt,
         });
+        await this.rebuildRuntimeMemoryVectorIndex();
         const writes = [];
         if (threadCandidates.length > 0) {
             writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
@@ -636,6 +899,28 @@ export class AgentHarnessRuntime {
                 config: this.runtimeMemoryMaintenanceConfig ?? undefined,
             }));
         }
+        if (userCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("user", binding, { userId }), "tool-memory.md", userCandidates, 20, "User Tool Memory"));
+            writes.push(consolidateStructuredMemoryScope({
+                store: this.runtimeMemoryStore,
+                namespace: this.resolveMemoryNamespace("user", binding, { userId }),
+                title: "User Structured Memory",
+                scope: "user",
+                maxEntries: 20,
+                config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+            }));
+        }
+        if (projectCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("project", binding, { projectId }), "tool-memory.md", projectCandidates, 20, "Project Tool Memory"));
+            writes.push(consolidateStructuredMemoryScope({
+                store: this.runtimeMemoryStore,
+                namespace: this.resolveMemoryNamespace("project", binding, { projectId }),
+                title: "Project Structured Memory",
+                scope: "project",
+                maxEntries: 20,
+                config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+            }));
+        }
         await Promise.all(writes);
         return persisted;
     }
@@ -909,10 +1194,12 @@ export class AgentHarnessRuntime {
         this.unregisterThreadMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
+        this.unregisterRuntimeMemoryFormationSync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
         await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();
+        await this.runtimeMemoryFormationSync?.close();
         await closeMcpClientsForWorkspace(this.workspace);
         this.initialized = false;
     }

package/dist/runtime/support/runtime-factories.js

@@ -3,7 +3,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
 import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
 import { ManagedSqliteSaver } from "../maintenance/sqlite-maintained-checkpoint-saver.js";
-import { createInMemoryStore, FileBackedStore } from "../harness/system/store.js";
+import { createInMemoryStore, FileBackedStore, SqliteBackedStore } from "../harness/system/store.js";
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {
@@ -11,6 +11,10 @@ export function createStoreForConfig(storeConfig, runRoot) {
             const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : "store.json";
             return new FileBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
         }
+        case "SqliteStore": {
+            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : "store.sqlite";
+            return new SqliteBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+        }
         case "InMemoryStore":
             return createInMemoryStore();
         case "RedisStore":

package/dist/runtime/support/vector-stores.js

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { Document } from "@langchain/core/documents";
 import { createClient } from "@libsql/client";
 import { LibSQLVectorStore } from "@langchain/community/vectorstores/libsql";
+import { QdrantClient } from "@qdrant/js-client-rest";
 import { compileVectorStore } from "../../workspace/resource-compilers.js";
 import { resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./embedding-models.js";
@@ -52,6 +53,27 @@ async function ensureLibSqlSchema(db, table, column, dimensions) {
     ON ${safeTable}(libsql_vector_idx(${safeColumn}))
   `);
 }
+function createQdrantClientForStore(vectorStore) {
+    return new QdrantClient({
+        ...(vectorStore.url ? { url: vectorStore.url } : {}),
+        ...(vectorStore.host ? { host: vectorStore.host } : {}),
+        ...(typeof vectorStore.port === "number" ? { port: vectorStore.port } : {}),
+        ...(vectorStore.authToken ? { apiKey: vectorStore.authToken } : {}),
+        checkCompatibility: false,
+    });
+}
+async function ensureQdrantCollection(client, collection, dimensions) {
+    const collections = await client.getCollections();
+    if (collections.collections.some((entry) => entry.name === collection)) {
+        return;
+    }
+    await client.createCollection(collection, {
+        vectors: {
+            size: dimensions,
+            distance: "Cosine",
+        },
+    });
+}
 export function resolveCompiledVectorStoreRef(workspace, vectorStoreRef) {
     const resolvedId = vectorStoreRef ? resolveRefId(vectorStoreRef) : "default";
     const vectorStore = workspace.vectorStores.get(resolvedId);
@@ -75,6 +97,81 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
         const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
         return createLlamaIndexVectorStore(workspace.workspaceRoot, vectorStore, embeddings);
     }
+    if (vectorStore.kind === "QdrantVectorStore") {
+        const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
+        const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
+        const client = createQdrantClientForStore(vectorStore);
+        const collection = vectorStore.collection ?? "vectors";
+        const ensureCollectionForTexts = async (texts) => {
+            const seedText = texts.find((text) => text.trim().length > 0) ?? "seed";
+            const sample = await embeddings.embedQuery(seedText);
+            await ensureQdrantCollection(client, collection, sample.length);
+        };
+        return {
+            kind: vectorStore.kind,
+            embeddingModelRef: vectorStore.embeddingModelRef,
+            addDocuments: async (documents) => {
+                if (documents.length === 0) {
+                    return [];
+                }
+                await ensureCollectionForTexts(documents.map((document) => document.pageContent));
+                const vectors = await embeddings.embedDocuments(documents.map((document) => document.pageContent));
+                const ids = documents.map((_, index) => `${Date.now()}-${index}-${Math.random().toString(36).slice(2, 10)}`);
+                await client.upsert(collection, {
+                    wait: true,
+                    points: documents.map((document, index) => ({
+                        id: ids[index] ?? index,
+                        vector: vectors[index] ?? [],
+                        payload: {
+                            pageContent: document.pageContent,
+                            ...(document.metadata ? { metadata: document.metadata } : {}),
+                        },
+                    })),
+                });
+                return ids;
+            },
+            similaritySearch: async (query, limit) => {
+                const collections = await client.getCollections();
+                if (!collections.collections.some((entry) => entry.name === collection)) {
+                    return [];
+                }
+                const queryVector = await embeddings.embedQuery(query);
+                const rows = await client.search(collection, {
+                    vector: queryVector,
+                    limit,
+                    with_payload: true,
+                });
+                return rows.map((row) => {
+                    const payload = (row.payload ?? {});
+                    return {
+                        pageContent: typeof payload.pageContent === "string" ? payload.pageContent : "",
+                        metadata: typeof payload.metadata === "object" && payload.metadata && !Array.isArray(payload.metadata)
+                            ? payload.metadata
+                            : {},
+                        score: typeof row.score === "number" ? row.score : undefined,
+                    };
+                });
+            },
+            delete: async (params) => {
+                const collections = await client.getCollections();
+                if (!collections.collections.some((entry) => entry.name === collection)) {
+                    return;
+                }
+                if (params.deleteAll) {
+                    await client.deleteCollection(collection);
+                    return;
+                }
+                const pointIds = (params.ids ?? []).filter((id) => typeof id === "string" || typeof id === "number");
+                if (pointIds.length === 0) {
+                    return;
+                }
+                await client.delete(collection, {
+                    wait: true,
+                    points: pointIds,
+                });
+            },
+        };
+    }
     if (vectorStore.kind !== "LibSQLVectorStore") {
         throw new Error(`Vector store kind ${vectorStore.kind} is not supported by the built-in runtime.`);
     }