@botbotgo/agent-harness 0.0.154 → 0.0.156

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/object-loader.js

@@ -6,7 +6,7 @@ import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
 import { isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath } from "../tool-modules.js";
 import { fileExists } from "../utils/fs.js";
-import { readNamedModelItems, readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
+import { readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
 export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
 const MODULE_AGENT_FILENAMES = ["agent.yaml", "agent.yml"];
@@ -39,16 +39,10 @@ function conventionalConfigRoot(root) {
 }
 function conventionalDirectoryRoots(root, relativeDir) {
     const resourceRoot = resolveResourcePackageRoot(root);
-    const configRoot = conventionalConfigRoot(root);
-    const candidates = relativeDir === "agents"
-        ? [
-            ...(configRoot ? [path.join(configRoot, "agents")] : []),
-            path.join(root, "agents"),
-        ]
-        : [
-            ...(resourceRoot ? [path.join(resourceRoot, relativeDir)] : []),
-            path.join(root, relativeDir),
-        ];
+    const candidates = [
+        ...(resourceRoot ? [path.join(resourceRoot, relativeDir)] : []),
+        path.join(root, relativeDir),
+    ];
     return Array.from(new Set(candidates));
 }
 export function conventionalPackageRoots(root, relativeDir) {
@@ -569,20 +563,6 @@ function mergeAgentRecord(records, item, sourcePath) {
 function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
     mergeRawItemRecord(records, `${workspaceObject.kind}/${workspaceObject.id}`, item, sourcePath);
 }
-async function loadNamedModelsForRoot(configRoot, mergedObjects) {
-    for (const { item, sourcePath } of await readNamedModelItems(configRoot)) {
-        const workspaceObject = parseWorkspaceObject(item, sourcePath);
-        if (!workspaceObject || workspaceObject.kind !== "model") {
-            continue;
-        }
-        mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
-    }
-}
-async function loadConfigAgentsForRoot(configRoot, mergedAgents) {
-    for (const { item, sourcePath } of await readConfigAgentItems(configRoot)) {
-        mergeAgentRecord(mergedAgents, item, sourcePath);
-    }
-}
 async function loadModuleAgentsForRoot(root, mergedAgents) {
     const modulesRoot = moduleCollectionRoot(root, "agents");
     if (!(await fileExists(modulesRoot))) {
@@ -675,7 +655,7 @@ async function loadModuleObjectsForRoot(root, mergedObjects) {
         mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
     }
 }
-async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
+async function loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects) {
     if (!conventionalConfigRoot(root)) {
         return;
     }
@@ -684,7 +664,8 @@ async function loadConfigObjectsForRoot(root, configRoot, mergedObjects) {
         if (!workspaceObject) {
             continue;
         }
-        if (isAgentKind(workspaceObject.kind) || workspaceObject.kind === "model") {
+        if (isAgentKind(workspaceObject.kind)) {
+            mergeAgentRecord(mergedAgents, item, sourcePath);
             continue;
         }
         mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
@@ -708,20 +689,6 @@ async function loadRootObjects(root, mergedObjects) {
 function isAgentKind(kind) {
     return kind === "agent";
 }
-async function readConfigAgentItems(configRoot) {
-    const records = await readYamlItems(configRoot, undefined, { recursive: true });
-    return records.filter(({ item, sourcePath }) => {
-        const kind = typeof item.kind === "string" ? item.kind : undefined;
-        if (!isAgentKind(kind)) {
-            return false;
-        }
-        const relativePath = path.relative(configRoot, sourcePath);
-        if (!relativePath || relativePath.startsWith("..")) {
-            return false;
-        }
-        return !relativePath.includes(path.sep) || relativePath.startsWith(`agents${path.sep}`);
-    });
-}
 export async function readToolModuleItems(root) {
     if (!(await fileExists(root))) {
         return [];
@@ -792,11 +759,9 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
     const roots = [frameworkWorkspaceRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
     for (const root of roots) {
         const configRoot = conventionalConfigRoot(root) ?? root;
-        await loadNamedModelsForRoot(configRoot, mergedObjects);
-        await loadConfigAgentsForRoot(configRoot, mergedAgents);
+        await loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects);
         await loadModuleAgentsForRoot(root, mergedAgents);
         await loadConventionalObjectsForRoot(root, mergedObjects);
-        await loadConfigObjectsForRoot(root, configRoot, mergedObjects);
         await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);
     }

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.d.ts

@@ -9,7 +9,3 @@ export declare function readNamedYamlItems(root: string, filenames: string[]): P
     item: Record<string, unknown>;
     sourcePath: string;
 }>>;
-export declare function readNamedModelItems(root: string): Promise<Array<{
-    item: Record<string, unknown>;
-    sourcePath: string;
-}>>;

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

@@ -2,7 +2,6 @@ import path from "node:path";
 import { readdir } from "node:fs/promises";
 import { parseAllDocuments } from "yaml";
 import { fileExists, listFilesRecursive, readYamlOrJson } from "../utils/fs.js";
-const MODEL_FILENAMES = ["models.yaml", "models.yml"];
 const ENV_PLACEHOLDER_PATTERN = /\$\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
@@ -62,6 +61,8 @@ function normalizeKind(kind) {
             return "agent";
         case "FileStore":
             return "file-store";
+        case "SqliteStore":
+            return "sqlite-store";
         case "InMemoryStore":
             return "in-memory-store";
         case "RedisStore":
@@ -163,7 +164,10 @@ export async function readYamlItems(root, relativeDir, options = {}) {
         return [];
     }
     const files = options.recursive
-        ? await listFilesRecursive(targetRoot, ".yaml")
+        ? Array.from(new Set([
+            ...(await listFilesRecursive(targetRoot, ".yaml")),
+            ...(await listFilesRecursive(targetRoot, ".yml")),
+        ])).sort()
         : (await readdir(targetRoot, { withFileTypes: true }))
             .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
             .map((entry) => path.join(targetRoot, entry.name))
@@ -197,33 +201,3 @@ export async function readNamedYamlItems(root, filenames) {
     }
     return records;
 }
-export async function readNamedModelItems(root) {
-    const filePaths = new Set();
-    for (const filename of MODEL_FILENAMES) {
-        const directPath = path.join(root, filename);
-        if (await fileExists(directPath)) {
-            filePaths.add(directPath);
-        }
-    }
-    for (const extension of [".yaml", ".yml"]) {
-        for (const filePath of await listFilesRecursive(root, extension)) {
-            if (MODEL_FILENAMES.includes(path.basename(filePath))) {
-                filePaths.add(filePath);
-            }
-        }
-    }
-    const records = [];
-    for (const filePath of [...filePaths].sort()) {
-        const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
-        for (const parsedDocument of parsedDocuments) {
-            const resolvedDocument = interpolateEnvPlaceholders(parsedDocument.toJSON(), filePath);
-            for (const item of await objectItemsFromDocument(resolvedDocument, filePath)) {
-                const normalized = normalizeYamlItem(item);
-                if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
-                    records.push({ item: normalized, sourcePath: filePath });
-                }
-            }
-        }
-    }
-    return records;
-}

package/package.json

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