@agentica/vector-selector 0.44.0-dev.20260313-2 → 0.44.1

package/src/strategy/postgres.strategy.ts

@@ -1,116 +1,116 @@
-import type { AgenticaContext, AgenticaOperation } from "@agentica/core";
-import type { IConnection } from "@wrtnlabs/connector-hive-api";
-import type { IApplicationConnectorRetrieval } from "@wrtnlabs/connector-hive-api/lib/structures/connector/IApplicationConnectorRetrieval";
-
-import { functional, HttpError } from "@wrtnlabs/connector-hive-api";
-
-import type { IAgenticaVectorSelectorStrategy } from "..";
-
-import { getRetry, groupByArray } from "../utils";
-
-const retry = getRetry(3);
-
-const filterMap = new Map<string, IApplicationConnectorRetrieval.IFilter>();
-function searchTool(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy["searchTool"] {
-  return async (ctx: AgenticaContext, query: string) => {
-    const filter = filterMap.get(JSON.stringify(ctx.operations.array));
-    return retry(async () =>
-      functional.connector_retrievals.createRetrievalRequest(connection, {
-        query,
-        limit: 10,
-        filter,
-      }),
-    );
-  };
-}
-
-function embedOperation(connection: IConnection<object | undefined>) {
-  return async (
-    controllerName: string,
-    opList: AgenticaOperation[],
-  ) => {
-    const application = await retry(async () =>
-      functional.applications.create(connection, {
-        name: controllerName,
-        description: undefined,
-      }),
-    ).catch(async (e) => {
-      if (!(e instanceof HttpError)) {
-        throw e;
-      }
-      if (e.status !== 409) {
-        throw e;
-      }
-
-      return retry(async () =>
-        functional.applications.by_names.getByName(
-          connection,
-          controllerName,
-        ),
-      );
-    });
-
-    const version = await retry(async () =>
-      functional.applications.by_ids.versions.create(
-        connection,
-        application.id,
-        {},
-      ),
-    );
-
-    // concurrency request count
-    await groupByArray(opList, 10).reduce(async (accPromise, cur) => {
-      await accPromise;
-      await Promise.all(
-        cur.map(async v =>
-          retry(async () =>
-            functional.application_versions.by_ids.connectors.create(
-              connection,
-              version.id,
-              { name: v.name, description: v.function.description ?? "" },
-            ),
-          ),
-        ),
-      );
-      return Promise.resolve();
-    }, Promise.resolve());
-
-    return { version, applicationId: application.id };
-  };
-}
-
-function embedContext(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy["embedContext"] {
-  return async (props: { ctx: AgenticaContext; setEmbedded: () => void }) => {
-    const { ctx, setEmbedded } = props;
-    const filter = await Promise.all(
-      Array.from(ctx.operations.group.entries()).map(
-        async ([key, value]: [
-          string,
-          Map<string, AgenticaOperation>,
-        ]) => {
-          const result = await embedOperation(connection)(
-            key,
-            Array.from(value.values()),
-          );
-
-          return {
-            id: result.applicationId,
-            version: result.version.version,
-            type: "byId",
-          } satisfies IApplicationConnectorRetrieval.IFilterApplicationById;
-        },
-      ),
-    );
-    filterMap.set(JSON.stringify(ctx.operations.array), {
-      applications: filter,
-    });
-    setEmbedded();
-  };
-}
-
-export function configurePostgresStrategy(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy {
-  return {
-    searchTool: searchTool(connection),
-    embedContext: embedContext(connection),
-  };
-}
+import type { AgenticaContext, AgenticaOperation } from "@agentica/core";
+import type { IConnection } from "@wrtnlabs/connector-hive-api";
+import type { IApplicationConnectorRetrieval } from "@wrtnlabs/connector-hive-api/lib/structures/connector/IApplicationConnectorRetrieval";
+
+import { functional, HttpError } from "@wrtnlabs/connector-hive-api";
+
+import type { IAgenticaVectorSelectorStrategy } from "..";
+
+import { getRetry, groupByArray } from "../utils";
+
+const retry = getRetry(3);
+
+const filterMap = new Map<string, IApplicationConnectorRetrieval.IFilter>();
+function searchTool(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy["searchTool"] {
+  return async (ctx: AgenticaContext, query: string) => {
+    const filter = filterMap.get(JSON.stringify(ctx.operations.array));
+    return retry(async () =>
+      functional.connector_retrievals.createRetrievalRequest(connection, {
+        query,
+        limit: 10,
+        filter,
+      }),
+    );
+  };
+}
+
+function embedOperation(connection: IConnection<object | undefined>) {
+  return async (
+    controllerName: string,
+    opList: AgenticaOperation[],
+  ) => {
+    const application = await retry(async () =>
+      functional.applications.create(connection, {
+        name: controllerName,
+        description: undefined,
+      }),
+    ).catch(async (e) => {
+      if (!(e instanceof HttpError)) {
+        throw e;
+      }
+      if (e.status !== 409) {
+        throw e;
+      }
+
+      return retry(async () =>
+        functional.applications.by_names.getByName(
+          connection,
+          controllerName,
+        ),
+      );
+    });
+
+    const version = await retry(async () =>
+      functional.applications.by_ids.versions.create(
+        connection,
+        application.id,
+        {},
+      ),
+    );
+
+    // concurrency request count
+    await groupByArray(opList, 10).reduce(async (accPromise, cur) => {
+      await accPromise;
+      await Promise.all(
+        cur.map(async v =>
+          retry(async () =>
+            functional.application_versions.by_ids.connectors.create(
+              connection,
+              version.id,
+              { name: v.name, description: v.function.description ?? "" },
+            ),
+          ),
+        ),
+      );
+      return Promise.resolve();
+    }, Promise.resolve());
+
+    return { version, applicationId: application.id };
+  };
+}
+
+function embedContext(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy["embedContext"] {
+  return async (props: { ctx: AgenticaContext; setEmbedded: () => void }) => {
+    const { ctx, setEmbedded } = props;
+    const filter = await Promise.all(
+      Array.from(ctx.operations.group.entries()).map(
+        async ([key, value]: [
+          string,
+          Map<string, AgenticaOperation>,
+        ]) => {
+          const result = await embedOperation(connection)(
+            key,
+            Array.from(value.values()),
+          );
+
+          return {
+            id: result.applicationId,
+            version: result.version.version,
+            type: "byId",
+          } satisfies IApplicationConnectorRetrieval.IFilterApplicationById;
+        },
+      ),
+    );
+    filterMap.set(JSON.stringify(ctx.operations.array), {
+      applications: filter,
+    });
+    setEmbedded();
+  };
+}
+
+export function configurePostgresStrategy(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy {
+  return {
+    searchTool: searchTool(connection),
+    embedContext: embedContext(connection),
+  };
+}

package/src/strategy/sqlite.strategy.ts

@@ -1,123 +1,123 @@
-import type { AgenticaContext, AgenticaOperation } from "@agentica/core";
-import type { Database } from "better-sqlite3";
-import type { Cohere } from "cohere-ai";
-
-import { CohereClientV2 } from "cohere-ai";
-import { load } from "sqlite-vec";
-
-import type { IAgenticaVectorSelectorStrategy } from "..";
-
-import { generateHashFromCtx, getRetry, groupByArray } from "../utils";
-
-export interface IAgenticaSqliteVectorSelectorStrategyProps {
-  db: Database;
-  cohereApiKey: string;
-}
-
-const retry = getRetry(3);
-const hashMemo = new Map<object, string>();
-export function configureSqliteStrategy(props: IAgenticaSqliteVectorSelectorStrategyProps): IAgenticaVectorSelectorStrategy {
-  const { db, cohereApiKey } = props;
-  load(db);
-
-  const cohere = new CohereClientV2({
-    token: cohereApiKey,
-  });
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS _agentica_vector_selector_embeddings (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      hash TEXT NOT NULL,
-      name TEXT NOT NULL,
-      description TEXT,
-      vector BLOB NOT NULL
-    )
-  `);
-
-  async function embed(text: string, inputType: Cohere.EmbedInputType) {
-    const result = await retry(async () => cohere.embed({
-      texts: [text],
-      inputType,
-      model: "embed-multilingual-light-v3.0",
-      embeddingTypes: ["float"],
-    }));
-
-    if ((result.embeddings.float == null) || result.embeddings.float.length === 0) {
-      throw new Error("no float embeddings returned");
-    }
-    const vector = result.embeddings.float[0]!;
-    return vector;
-  }
-  // it's memoized to avoid generating the same hash for the same context
-  // if you know react, it's like useMemo
-  const getHash = (ctx: AgenticaContext) => {
-    if (hashMemo.has(ctx)) {
-      return hashMemo.get(ctx)!;
-    }
-    const hash = generateHashFromCtx(ctx);
-    hashMemo.set(ctx, hash);
-    return hash;
-  };
-
-  // embed each operation in the context.opersation.array
-  async function embedOperation(props: {
-    hash: string;
-    operation: AgenticaOperation;
-  }): Promise<void> {
-    const name = props.operation.function.name;
-
-    const embedding = await retry(async () => embed(props.operation.function.description ?? name, "search_document"));
-
-    db
-
-      .prepare("INSERT INTO _agentica_vector_selector_embeddings (hash, name, description, vector) VALUES (?, ?, ?, vec_f32(?))")
-
-      .run(props.hash, name, props.operation.function.description, JSON.stringify(embedding));
-  }
-
-  async function embedContext(props: {
-    ctx: AgenticaContext;
-    setEmbedded: () => void;
-  }): Promise<void> {
-    const hash = getHash(props.ctx);
-
-    const prepared = db.prepare(`SELECT name FROM _agentica_vector_selector_embeddings WHERE hash = ?`).all(hash);
-    if (prepared.length > 0) {
-      props.setEmbedded();
-      return;
-    }
-
-    await groupByArray(props.ctx.operations.array, 10).reduce(async (accPromise, cur) => {
-      await accPromise;
-      await Promise.all(cur.map(async v => embedOperation({ hash, operation: v })));
-      return Promise.resolve();
-    }, Promise.resolve());
-    props.setEmbedded();
-  }
-
-  async function searchTool(ctx: AgenticaContext, query: string): Promise<{
-    name: string;
-    description: string | undefined;
-  }[]> {
-    const hash = getHash(ctx);
-    const vector = await embed(query, "search_query");
-
-    const result = db.prepare(`
-        SELECT name, description, vec_distance_L2(vector, ?) as distance
-        FROM _agentica_vector_selector_embeddings
-        WHERE hash = ?
-        ORDER BY distance
-        LIMIT 10
-    `).all(JSON.stringify(vector), hash) as {
-      name: string;
-      description: string;
-      distance: number;
-    }[];
-    return result;
-  }
-
-  return {
-    searchTool,
-    embedContext,
-  };
-}
+import type { AgenticaContext, AgenticaOperation } from "@agentica/core";
+import type { Database } from "better-sqlite3";
+import type { Cohere } from "cohere-ai";
+
+import { CohereClientV2 } from "cohere-ai";
+import { load } from "sqlite-vec";
+
+import type { IAgenticaVectorSelectorStrategy } from "..";
+
+import { generateHashFromCtx, getRetry, groupByArray } from "../utils";
+
+export interface IAgenticaSqliteVectorSelectorStrategyProps {
+  db: Database;
+  cohereApiKey: string;
+}
+
+const retry = getRetry(3);
+const hashMemo = new Map<object, string>();
+export function configureSqliteStrategy(props: IAgenticaSqliteVectorSelectorStrategyProps): IAgenticaVectorSelectorStrategy {
+  const { db, cohereApiKey } = props;
+  load(db);
+
+  const cohere = new CohereClientV2({
+    token: cohereApiKey,
+  });
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _agentica_vector_selector_embeddings (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      hash TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      vector BLOB NOT NULL
+    )
+  `);
+
+  async function embed(text: string, inputType: Cohere.EmbedInputType) {
+    const result = await retry(async () => cohere.embed({
+      texts: [text],
+      inputType,
+      model: "embed-multilingual-light-v3.0",
+      embeddingTypes: ["float"],
+    }));
+
+    if ((result.embeddings.float == null) || result.embeddings.float.length === 0) {
+      throw new Error("no float embeddings returned");
+    }
+    const vector = result.embeddings.float[0]!;
+    return vector;
+  }
+  // it's memoized to avoid generating the same hash for the same context
+  // if you know react, it's like useMemo
+  const getHash = (ctx: AgenticaContext) => {
+    if (hashMemo.has(ctx)) {
+      return hashMemo.get(ctx)!;
+    }
+    const hash = generateHashFromCtx(ctx);
+    hashMemo.set(ctx, hash);
+    return hash;
+  };
+
+  // embed each operation in the context.opersation.array
+  async function embedOperation(props: {
+    hash: string;
+    operation: AgenticaOperation;
+  }): Promise<void> {
+    const name = props.operation.function.name;
+
+    const embedding = await retry(async () => embed(props.operation.function.description ?? name, "search_document"));
+
+    db
+
+      .prepare("INSERT INTO _agentica_vector_selector_embeddings (hash, name, description, vector) VALUES (?, ?, ?, vec_f32(?))")
+
+      .run(props.hash, name, props.operation.function.description, JSON.stringify(embedding));
+  }
+
+  async function embedContext(props: {
+    ctx: AgenticaContext;
+    setEmbedded: () => void;
+  }): Promise<void> {
+    const hash = getHash(props.ctx);
+
+    const prepared = db.prepare(`SELECT name FROM _agentica_vector_selector_embeddings WHERE hash = ?`).all(hash);
+    if (prepared.length > 0) {
+      props.setEmbedded();
+      return;
+    }
+
+    await groupByArray(props.ctx.operations.array, 10).reduce(async (accPromise, cur) => {
+      await accPromise;
+      await Promise.all(cur.map(async v => embedOperation({ hash, operation: v })));
+      return Promise.resolve();
+    }, Promise.resolve());
+    props.setEmbedded();
+  }
+
+  async function searchTool(ctx: AgenticaContext, query: string): Promise<{
+    name: string;
+    description: string | undefined;
+  }[]> {
+    const hash = getHash(ctx);
+    const vector = await embed(query, "search_query");
+
+    const result = db.prepare(`
+        SELECT name, description, vec_distance_L2(vector, ?) as distance
+        FROM _agentica_vector_selector_embeddings
+        WHERE hash = ?
+        ORDER BY distance
+        LIMIT 10
+    `).all(JSON.stringify(vector), hash) as {
+      name: string;
+      description: string;
+      distance: number;
+    }[];
+    return result;
+  }
+
+  return {
+    searchTool,
+    embedContext,
+  };
+}

package/src/tools.ts

@@ -1,99 +1,99 @@
-import type { AgenticaContext } from "@agentica/core";
-
-export const Tools = {
-  extract_query: {
-    type: "function",
-    function: {
-      name: "extract_search_query",
-      description: "extract search query from user message\n",
-      parameters: {
-        type: "object",
-        properties: {
-          query_list: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                reason: {
-                  type: "string",
-                  description: "The reason of the query selection.\n\nJust write the reason why you've determined to select this query.",
-                },
-                query: {
-                  type: "string",
-                  description: "the search query",
-                },
-              },
-              required: ["reason", "query"],
-            },
-          },
-        },
-        required: ["query_list"],
-      },
-    },
-  },
-
-  select_functions: {
-    type: "function",
-    function: {
-      name: "select_functions",
-      description: `Select proper API functions to call.
-
-If you A.I. agent has found some proper API functions to call
-from the conversation with user, please select the API functions
-just by calling this function.
-
-When user wants to call a same function multiply, you A.I. agent must
-list up it multiply in the \`functions\` property. Otherwise the user has
-requested to call many different functions, you A.I. agent have to assign
-them all into the \`functions\` property.
-
-Also, if you A.I. agent can't specify a specific function to call due to lack
-of specificity or homogeneity of candidate functions, just assign all of them
-by in the \`functions\` property too. Instead, when you A.I. agent can specify
-a specific function to call, the others would be eliminated.
-
-@example
-\`\`\`json
-[
-  {
-    "reason": "The user wants to call the function multiply.",
-    "function_name": "get_user_info"
-  },
-  {
-    "reason": "The user wants to modify the user info.",
-    "function_name": "modify_user_info"
-  }
-]
-\`\`\`
-`,
-      parameters: {
-        type: "object",
-        properties: {
-          function_list: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                reason: {
-                  type: "string",
-                  description: "The reason of the function selection.\n\nJust write the reason why you've determined to select this function.",
-                },
-                function_name: {
-                  type: "string",
-                  description: "Name of the target function to call.",
-                },
-              },
-              required: ["reason", "function_name"],
-            },
-          },
-        },
-        required: ["function_list"],
-      },
-    },
-  },
-} as const satisfies Record<
-  string,
-  NonNullable<
-    Parameters<AgenticaContext["request"]>[1]["tools"]
-  >[number]
->;
+import type { AgenticaContext } from "@agentica/core";
+
+export const Tools = {
+  extract_query: {
+    type: "function",
+    function: {
+      name: "extract_search_query",
+      description: "extract search query from user message\n",
+      parameters: {
+        type: "object",
+        properties: {
+          query_list: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                reason: {
+                  type: "string",
+                  description: "The reason of the query selection.\n\nJust write the reason why you've determined to select this query.",
+                },
+                query: {
+                  type: "string",
+                  description: "the search query",
+                },
+              },
+              required: ["reason", "query"],
+            },
+          },
+        },
+        required: ["query_list"],
+      },
+    },
+  },
+
+  select_functions: {
+    type: "function",
+    function: {
+      name: "select_functions",
+      description: `Select proper API functions to call.
+
+If you A.I. agent has found some proper API functions to call
+from the conversation with user, please select the API functions
+just by calling this function.
+
+When user wants to call a same function multiply, you A.I. agent must
+list up it multiply in the \`functions\` property. Otherwise the user has
+requested to call many different functions, you A.I. agent have to assign
+them all into the \`functions\` property.
+
+Also, if you A.I. agent can't specify a specific function to call due to lack
+of specificity or homogeneity of candidate functions, just assign all of them
+by in the \`functions\` property too. Instead, when you A.I. agent can specify
+a specific function to call, the others would be eliminated.
+
+@example
+\`\`\`json
+[
+  {
+    "reason": "The user wants to call the function multiply.",
+    "function_name": "get_user_info"
+  },
+  {
+    "reason": "The user wants to modify the user info.",
+    "function_name": "modify_user_info"
+  }
+]
+\`\`\`
+`,
+      parameters: {
+        type: "object",
+        properties: {
+          function_list: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                reason: {
+                  type: "string",
+                  description: "The reason of the function selection.\n\nJust write the reason why you've determined to select this function.",
+                },
+                function_name: {
+                  type: "string",
+                  description: "Name of the target function to call.",
+                },
+              },
+              required: ["reason", "function_name"],
+            },
+          },
+        },
+        required: ["function_list"],
+      },
+    },
+  },
+} as const satisfies Record<
+  string,
+  NonNullable<
+    Parameters<AgenticaContext["request"]>[1]["tools"]
+  >[number]
+>;