@botbotgo/agent-harness 0.0.153 → 0.0.155

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.`);
     }

package/dist/workspace/resource-compilers.js

@@ -89,13 +89,21 @@ export function parseEmbeddingModelObject(object) {
 }
 export function parseVectorStoreObject(object) {
     const value = object.value;
+    const port = typeof value.port === "number" && Number.isInteger(value.port) ? value.port : undefined;
     return {
         id: object.id,
         kind: String(value.storeKind ?? value.kind ?? "LibSQLVectorStore").trim(),
         url: typeof value.url === "string" ? value.url : undefined,
+        host: typeof value.host === "string" ? value.host : undefined,
+        port,
         authToken: typeof value.authToken === "string" ? value.authToken : undefined,
         table: typeof value.table === "string" ? value.table : undefined,
         column: typeof value.column === "string" ? value.column : undefined,
+        collection: typeof value.collection === "string"
+            ? value.collection
+            : typeof value.collectionName === "string"
+                ? value.collectionName
+                : undefined,
         embeddingModelRef: typeof value.embeddingModelRef === "string"
             ? value.embeddingModelRef
             : typeof asObject(value.embeddingModel)?.ref === "string"
@@ -155,6 +163,14 @@ export function validateVectorStoreObject(vectorStore) {
     if ((vectorStore.kind === "LibSQLVectorStore" || vectorStore.kind === "LlamaIndexSimpleVectorStore") && !vectorStore.url) {
         throw new Error(`Vector store ${vectorStore.id} url must not be empty for ${vectorStore.kind}`);
     }
+    if (vectorStore.kind === "QdrantVectorStore") {
+        if (!vectorStore.url && !vectorStore.host) {
+            throw new Error(`Vector store ${vectorStore.id} must define url or host for QdrantVectorStore`);
+        }
+        if (!vectorStore.collection) {
+            throw new Error(`Vector store ${vectorStore.id} collection must not be empty for QdrantVectorStore`);
+        }
+    }
 }
 export function validateMcpServerObject(server) {
     if (!server.id.trim()) {
@@ -186,9 +202,12 @@ export function compileVectorStore(vectorStore) {
         id: vectorStore.id,
         kind: vectorStore.kind,
         url: vectorStore.url,
+        host: vectorStore.host,
+        port: vectorStore.port,
         authToken: vectorStore.authToken,
         table: vectorStore.table,
         column: vectorStore.column,
+        collection: vectorStore.collection,
         embeddingModelRef: vectorStore.embeddingModelRef,
         runtimeValue: vectorStore.kind,
     };

package/dist/workspace/yaml-object-reader.js

@@ -62,6 +62,8 @@ function normalizeKind(kind) {
             return "agent";
         case "FileStore":
             return "file-store";
+        case "SqliteStore":
+            return "sqlite-store";
         case "InMemoryStore":
             return "in-memory-store";
         case "RedisStore":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.153",
+  "version": "0.0.155",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",