@agentica/vector-selector 0.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wrtn Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# Agentica, AI Function Calling Framework
+
+<!-- https://github.com/user-attachments/assets/5326cc59-5129-470d-abcb-c3f458b5c488 -->
+
+![Logo](https://wrtnlabs.io/agentica/logo.png)
+
+[![GitHub License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/wrtnlabs/agentica/blob/master/LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@agentica/core.svg)](https://www.npmjs.com/package/@agentica/core)
+[![NPM Downloads](https://img.shields.io/npm/dm/@agentica/core.svg)](https://www.npmjs.com/package/@agentica/core)
+[![Build Status](https://github.com/wrtnlabs/agentica/workflows/build/badge.svg)](https://github.com/wrtnlabs/agentica/actions?query=workflow%3Abuild)
+[![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://wrtnlabs.io/agentica/)
+[![Discord Badge](https://dcbadge.limes.pink/api/server/https://discord.gg/aMhRmzkqCx?style=flat)](https://discord.gg/aMhRmzkqCx)
+
+Agentic AI framework specialized in AI Function Calling.
+
+Don't be afraid of AI agent development. Just list functions from three protocols below. This is everything you should do for AI agent development.
+
+- TypeScript Class
+- Swagger/OpenAPI Document
+- MCP (Model Context Protocol) Server
+
+Wanna make an e-commerce agent? Bring in e-commerce functions. Need a newspaper agent? Get API functions from the newspaper company. Just prepare any functions that you need, then it becomes an AI agent.
+
+Are you a TypeScript developer? Then you're already an AI developer. Familiar with backend development? You're already well-versed in AI development. Anyone who can make functions can make AI agents.
+
+<!-- eslint-skip -->
+
+```typescript
+import { Agentica, assertHttpLlmApplication } from "@agentica/core";
+import OpenAI from "openai";
+import typia from "typia";
+
+import { MobileFileSystem } from "./services/MobileFileSystem";
+
+const agent = new Agentica({
+  vendor: {
+    api: new OpenAI({ apiKey: "********" }),
+    model: "gpt-4o-mini",
+  },
+  controllers: [
+    // functions from TypeScript class
+    {
+      protocol: "http",
+      application: typia.llm.application<MobileFileSystem, "chatgpt">(),
+      execute: new MobileFileSystem(),
+    },
+    // functions from Swagger/OpenAPI
+    {
+      protocol: "http",
+      application: assertHttpLlmApplication({
+        model: "chatgpt",
+        document: await fetch(
+          "https://shopping-be.wrtn.ai/editor/swagger.json",
+        ).then(r => r.json()),
+      }),
+      connection: {
+        host: "https://shopping-be.wrtn.ai",
+        headers: { Authorization: "Bearer ********" },
+      },
+    },
+  ],
+});
+await agent.conversate("I wanna buy MacBook Pro");
+```
+
+## 📦 Setup
+
+```bash
+$ npx agentica start <directory>
+
+----------------------------------------
+ Agentica Setup Wizard
+----------------------------------------
+? Package Manager (use arrow keys)
+  > npm
+    pnpm
+    yarn (berry is not supported)
+? Project Type
+    NodeJS Agent Server
+  > NestJS Agent Server
+    React Client Application
+    Standalone Application
+? Embedded Controllers (multi-selectable)
+    (none)
+    Google Calendar
+    Google News
+  > Github
+    Reddit
+    Slack
+    ...
+```
+
+The setup wizard helps you create a new project tailored to your needs.
+
+For reference, when selecting a project type, any option other than "Standalone Application" will implement the [WebSocket Protocol](https://wrtnlabs.io/agentica/docs/websocket/) for client-server communication.
+
+For comprehensive setup instructions, visit our [Getting Started](https://wrtnlabs.io/agentica/docs/) guide.
+
+## 💻 Playground
+
+Experience Agentica firsthand through our [interactive playground](https://wrtnlabs.io/agentica/playground) before installing.
+
+Our demonstrations showcase the power and simplicity of Agentica's function calling capabilities across different integration methods.
+
+- [TypeScript Class](https://wrtnlabs.io/agentica/playground/bbs)
+- [Swagger/OpenAPI Document](https://wrtnlabs.io/agentica/playground/swagger)
+- [Enterprise E-commerce Agent](https://wrtnlabs.io/agentica/playground/shopping)
+
+<!--
+@todo this section would be changed after making tutorial playground
+-->
+
+## 📚 Documentation Resources
+
+Find comprehensive resources at our [official website](https://wrtnlabs.io/agentica).
+
+- [Home](https://wrtnlabs.io/agentica)
+- [Guide Documents](https://wrtnlabs.io/agentica/docs)
+- [Tutorial](https://wrtnlabs.io/agentica/tutorial)
+- [API Documents](https://wrtnlabs.io/agentica/api)
+- [Youtube](https://www.youtube.com/@wrtnlabs)
+- [Paper](https://wrtnlabs.io/agentica/paper)
+
+## 🌟 Why Agentica?
+
+```mermaid
+flowchart
+  subgraph "JSON Schema Specification"
+    schemav4("JSON Schema v4 ~ v7") --upgrades--> emended[["OpenAPI v3.1 (emended)"]]
+    schema2910("JSON Schema 2019-03") --upgrades--> emended
+    schema2020("JSON Schema 2020-12") --emends--> emended
+  end
+  subgraph "Agentica"
+    emended --"Artificial Intelligence"--> fc{{"AI Function Calling"}}
+    fc --"OpenAI"--> chatgpt("ChatGPT")
+    fc --"Google"--> gemini("Gemini")
+    fc --"Anthropic"--> claude("Claude")
+    fc --"High-Flyer"--> deepseek("DeepSeek")
+    fc --"Meta"--> llama("Llama")
+    chatgpt --"3.1"--> custom(["Custom JSON Schema"])
+    gemini --"3.0"--> custom(["Custom JSON Schema"])
+    claude --"3.1"--> standard(["Standard JSON Schema"])
+    deepseek --"3.1"--> standard
+    llama --"3.1"--> standard
+  end
+```
+
+Agentica enhances AI function calling by the following strategies:
+
+- [**JSON schema conversion**](https://wrtnlabs.io/agentica/docs/core/vendor/#schema-specification): Automatically handles specification differences between LLM vendors, ensuring seamless integration regardless of your chosen AI model.
+- [**Validation Feedback**](https://wrtnlabs.io/agentica/docs/concepts/function-calling#validation-feedback): Detects and corrects AI mistakes in argument composition, dramatically reducing errors and improving reliability.
+- [**Selector Agent**](https://wrtnlabs.io/agentica/docs/concepts/function-calling#orchestration-strategy): Filtering candidate functions to minimize context usage, optimize performance, and reduce token consumption.
+
+Thanks to these innovations, Agentica makes AI function calling easier, safer, and more accurate than before. Development becomes more intuitive since you only need to prepare functions relevant to your specific use case, and scaling your agent's capabilities is as simple as adding or removing functions.
+
+In 2023, when OpenAI announced function calling, many predicted that function calling-driven AI development would become the mainstream. However, in reality, due to the difficulty and instability of function calling, the trend in AI development became agent workflow. Agent workflow, which is inflexible and must be created for specific purposes, has conquered the AI agent ecosystem.
+By the way, as Agentica has resolved the difficulty and instability problems of function calling, the time has come to embrace function-driven AI development once again.
+
+| Type        | Workflow      | Vanilla Function Calling | Agentica Function Calling |
+| ----------- | ------------- | ------------------------ | ------------------------- |
+| Purpose     | ❌ Specific   | 🟢 General               | 🟢 General                |
+| Difficulty  | ❌ Difficult  | ❌ Difficult             | 🟢 Easy                   |
+| Stability   | 🟢 Stable     | ❌ Unstable              | 🟢 Stable                 |
+| Flexibility | ❌ Inflexible | 🟢 Flexible              | 🟢 Flexible               |

package/lib/embed.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=embed.js.map

package/lib/embed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.js","sourceRoot":"","sources":["../src/embed.ts"],"names":[],"mappings":""}

package/lib/extract_query.d.ts

@@ -0,0 +1,3 @@
+import type { AgenticaContext } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+export declare function extractQuery<SchemaModel extends ILlmSchema.Model>(ctx: AgenticaContext<SchemaModel>): Promise<string[]>;

package/lib/extract_query.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractQuery = extractQuery;
+const core_1 = require("@agentica/core");
+const tools_1 = require("./tools");
+function extractQuery(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const completionStream = yield ctx.request("select", {
+            messages: [
+                {
+                    role: "system",
+                    content: [
+                        "You are a function searcher. You will extract search queries from the user's message, and the query results will be function names.",
+                        "A query is a 2–3 sentence description of the action the user needs to perform.",
+                        "Therefore, the extracted queries must be suitable for function search.",
+                        "You need to identify the actions required to achieve what the user wants and extract queries that can be used to search for those actions.",
+                        "Extract only one query per task.",
+                    ].join("\n"),
+                },
+                ...ctx.histories
+                    .map((core_1.factory.decodeHistory))
+                    .flat(),
+                {
+                    role: "user",
+                    content: ctx.prompt.text,
+                },
+            ],
+            tool_choice: "required",
+            tools: [tools_1.Tools.extract_query],
+        });
+        const chunks = yield core_1.utils.StreamUtil.readAll(completionStream);
+        const completion = core_1.utils.ChatGptCompletionMessageUtil.merge(chunks);
+        const queries = (_c = (_b = (_a = completion.choices[0]) === null || _a === void 0 ? void 0 : _a.message.tool_calls) === null || _b === void 0 ? void 0 : _b.flatMap((v) => {
+            const arg = JSON.parse(v.function.arguments);
+            if (!Array.isArray(arg.query_list)) {
+                return [];
+            }
+            return arg.query_list.map(v => v.query);
+        })) !== null && _c !== void 0 ? _c : [];
+        return queries;
+    });
+}
+//# sourceMappingURL=extract_query.js.map

package/lib/extract_query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract_query.js","sourceRoot":"","sources":["../src/extract_query.ts"],"names":[],"mappings":";;;;;;;;;;;AAQA,oCAsCC;AA1CD,yCAAgD;AAEhD,mCAAgC;AAEhC,SAAsB,YAAY,CAAuC,GAAiC;;;QACxG,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE;YACnD,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE;wBACP,qIAAqI;wBACrI,gFAAgF;wBAChF,wEAAwE;wBACxE,4IAA4I;wBAC5I,kCAAkC;qBACnC,CAAC,IAAI,CAAC,IAAI,CAAC;iBACb;gBACD,GAAG,GAAG,CAAC,SAAS;qBACb,GAAG,CAAC,CAAA,cAAO,CAAC,aAA0B,CAAA,CAAC;qBACvC,IAAI,EAAE;gBACT;oBACE,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI;iBACzB;aACF;YACD,WAAW,EAAE,UAAU;YAEvB,KAAK,EAAE,CAAC,aAAK,CAAC,aAAa,CAAC;SAC7B,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,MAAM,YAAK,CAAC,UAAU,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAChE,MAAM,UAAU,GAAG,YAAK,CAAC,4BAA4B,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpE,MAAM,OAAO,GAAG,MAAA,MAAA,MAAA,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,0CAAE,OAAO,CAAC,UAAU,0CAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACvE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAwE,CAAC;YACpH,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACnC,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC,CAAC,mCAAI,EAAE,CAAC;QAET,OAAO,OAAO,CAAC;IACjB,CAAC;CAAA"}

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import type { AgenticaContext, AgenticaHistory } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+export interface IAgenticaVectorSelectorBootProps<SchemaModel extends ILlmSchema.Model> {
+    strategy: IAgenticaVectorSelectorStrategy<SchemaModel>;
+}
+export interface IAgenticaVectorSelectorStrategy<SchemaModel extends ILlmSchema.Model> {
+    searchTool: (ctx: AgenticaContext<SchemaModel>, query: string) => Promise<{
+        name: string;
+        description: string | undefined;
+    }[]>;
+    embedContext: (props: {
+        ctx: AgenticaContext<SchemaModel>;
+        setEmbedded: () => void;
+    }) => Promise<void>;
+}
+export declare function BootAgenticaVectorSelector<SchemaModel extends ILlmSchema.Model>(props: IAgenticaVectorSelectorBootProps<SchemaModel>): (ctx: AgenticaContext<SchemaModel>) => Promise<AgenticaHistory<SchemaModel>[]>;
+export declare function useEmbeddedContext<SchemaModel extends ILlmSchema.Model>(): {
+    readonly isEmbedded: (ctx: AgenticaContext<SchemaModel>) => boolean;
+    readonly setEmbedded: (ctx: AgenticaContext<SchemaModel>) => void;
+};

package/lib/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootAgenticaVectorSelector = BootAgenticaVectorSelector;
+exports.useEmbeddedContext = useEmbeddedContext;
+const extract_query_1 = require("./extract_query");
+const select_1 = require("./select");
+const utils_1 = require("./utils");
+function BootAgenticaVectorSelector(props) {
+    const { isEmbedded, setEmbedded } = useEmbeddedContext();
+    const { searchTool, embedContext } = props.strategy;
+    const selectorExecute = (ctx) => __awaiter(this, void 0, void 0, function* () {
+        if (!isEmbedded(ctx)) {
+            yield embedContext({ ctx, setEmbedded: () => setEmbedded(ctx) });
+        }
+        const queries = yield (0, extract_query_1.extractQuery)(ctx);
+        const toolList = yield Promise.all(queries.map((query) => __awaiter(this, void 0, void 0, function* () { return searchTool(ctx, query); }))).then(res => res.flatMap(output => output.map(v => ({
+            name: v.name,
+            description: v.description,
+        }))).map((v) => {
+            const op = ctx.operations.flat.get(v.name);
+            if (op === undefined || op.protocol !== "http") {
+                return v;
+            }
+            return Object.assign(Object.assign({}, v), { method: op.function.method, path: op.function.path, tags: op.function.tags });
+        })).then(arr => (0, utils_1.uniqBy)(arr, v => v.name));
+        if (toolList.length === 0) {
+            return [];
+        }
+        const prompts = yield (0, select_1.selectFunction)({ ctx, toolList });
+        return prompts;
+    });
+    return selectorExecute;
+}
+function useEmbeddedContext() {
+    const set = new Set();
+    return {
+        isEmbedded: (ctx) => set.has(JSON.stringify(ctx.operations.array)),
+        setEmbedded: (ctx) => {
+            set.add(JSON.stringify(ctx.operations.array));
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;AAuBA,gEA2CC;AAED,gDASC;AA1ED,mDAA+C;AAC/C,qCAA0C;AAC1C,mCAAiC;AAkBjC,SAAgB,0BAA0B,CAAuC,KAAoD;IACnI,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,kBAAkB,EAAe,CAAC;IACtE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC;IACpD,MAAM,eAAe,GAAG,CACtB,GAAiC,EACQ,EAAE;QAC3C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,YAAY,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACnE,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAA,4BAAY,EAAC,GAAG,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,OAAO,CAAC,GAAG,CAAC,CAAM,KAAK,EAAC,EAAE,gDAAC,OAAA,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA,GAAA,CAAC,CACnD,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CACX,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CACnB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACf,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,WAAW,EAAE,CAAC,CAAC,WAAW;SAC3B,CAAC,CAAC,CACJ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACV,MAAM,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;gBAC/C,OAAO,CAAC,CAAC;YACX,CAAC;YAED,uCACK,CAAC,KACJ,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,EAC1B,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EACtB,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,IACtB;QACJ,CAAC,CAAC,CACH,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAA,cAAM,EAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAExC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAA,uBAAc,EAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxD,OAAO,OAAO,CAAC;IACjB,CAAC,CAAA,CAAC;IAEF,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,SAAgB,kBAAkB;IAChC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,OAAO;QACL,UAAU,EAAE,CAAC,GAAiC,EAAE,EAAE,CAChD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC/C,WAAW,EAAE,CAAC,GAAiC,EAAE,EAAE;YACjD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;QAChD,CAAC;KACO,CAAC;AACb,CAAC"}

package/lib/index.mjs

@@ -0,0 +1,312 @@
+import { factory, utils } from "@agentica/core";
+
+import { AgenticaDefaultPrompt } from "@agentica/core/src/constants/AgenticaDefaultPrompt";
+
+import { AgenticaSystemPrompt } from "@agentica/core/src/constants/AgenticaSystemPrompt";
+
+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.\n\nIf you A.I. agent has found some proper API functions to call\nfrom the conversation with user, please select the API functions\njust by calling this function.\n\nWhen user wants to call a same function multiply, you A.I. agent must\nlist up it multiply in the \`functions\` property. Otherwise the user has\nrequested to call many different functions, you A.I. agent have to assign\nthem all into the \`functions\` property.\n\nAlso, if you A.I. agent can't specify a specific function to call due to lack\nof specificity or homogeneity of candidate functions, just assign all of them\nby in the \`functions\` property too. Instead, when you A.I. agent can specify\na specific function to call, the others would be eliminated.\n\n@example\n\`\`\`json\n[\n  {\n    "reason": "The user wants to call the function multiply.",\n    "function_name": "get_user_info"\n  },\n  {\n    "reason": "The user wants to modify the user info.",\n    "function_name": "modify_user_info"\n  }\n]\n\`\`\`\n`,
+            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" ]
+            }
+        }
+    }
+};
+
+async function extractQuery(ctx) {
+    const completionStream = await ctx.request("select", {
+        messages: [ {
+            role: "system",
+            content: [ "You are a function searcher. You will extract search queries from the user's message, and the query results will be function names.", "A query is a 2–3 sentence description of the action the user needs to perform.", "Therefore, the extracted queries must be suitable for function search.", "You need to identify the actions required to achieve what the user wants and extract queries that can be used to search for those actions.", "Extract only one query per task." ].join("\n")
+        }, ...ctx.histories.map(factory.decodeHistory).flat(), {
+            role: "user",
+            content: ctx.prompt.text
+        } ],
+        tool_choice: "required",
+        tools: [ Tools.extract_query ]
+    });
+    const chunks = await utils.StreamUtil.readAll(completionStream);
+    const completion = utils.ChatGptCompletionMessageUtil.merge(chunks);
+    const queries = completion.choices[0]?.message.tool_calls?.flatMap((v => {
+        const arg = JSON.parse(v.function.arguments);
+        if (!Array.isArray(arg.query_list)) {
+            return [];
+        }
+        return arg.query_list.map((v => v.query));
+    })) ?? [];
+    return queries;
+}
+
+async function selectFunction(props) {
+    const {ctx, toolList, prevFailures = [], restRetry = 5} = props;
+    const selectCompletion = await ctx.request("select", {
+        messages: [ {
+            role: "system",
+            content: AgenticaDefaultPrompt.write(ctx.config)
+        }, {
+            role: "assistant",
+            tool_calls: [ {
+                type: "function",
+                id: "getApiFunctions",
+                function: {
+                    name: "getApiFunctions",
+                    arguments: JSON.stringify({})
+                }
+            } ]
+        }, {
+            role: "tool",
+            tool_call_id: "getApiFunctions",
+            content: JSON.stringify(toolList)
+        }, ...ctx.histories.flatMap(factory.decodeHistory), {
+            role: "user",
+            content: ctx.prompt.text
+        }, {
+            role: "system",
+            content: `${ctx.config?.systemPrompt?.select?.(ctx.histories) ?? AgenticaSystemPrompt.SELECT}\n          \n        \n        When selecting functions, consider what the user can call from their perspective, and choose all the functions necessary to accomplish the task.\n        Select them in a logical sequence, taking into account the relationships between each function.\n        `
+        }, ...emendMessages(prevFailures) ],
+        tool_choice: {
+            type: "function",
+            function: {
+                name: "select_functions"
+            }
+        },
+        parallel_tool_calls: false,
+        tools: [ Tools.select_functions ]
+    }).then((async v => utils.StreamUtil.readAll(v))).then(utils.ChatGptCompletionMessageUtil.merge);
+    const toolCalls = selectCompletion.choices.filter((v => v.message.tool_calls != null));
+    if (toolCalls.length === 0) {
+        return selectCompletion.choices.flatMap((v => {
+            if (v.message.content != null && v.message.content !== "") {
+                return [ factory.createTextHistory({
+                    role: "assistant",
+                    text: v.message.content
+                }) ];
+            }
+            return [];
+        }));
+    }
+    const failures = toolCalls.reduce(((acc, cur) => {
+        cur.message.tool_calls?.forEach((tc => {
+            const errors = [];
+            const arg = JSON.parse(tc.function.arguments);
+            if (!Array.isArray(arg)) {
+                errors.push(JSON.stringify({
+                    path: "$input",
+                    expected: "array",
+                    value: arg
+                }));
+                return;
+            }
+            arg.forEach(((v, idx) => {
+                if (v.reason == null || typeof v.reason !== "string") {
+                    errors.push(JSON.stringify({
+                        path: `$$input[${idx}].reason`,
+                        expected: "string",
+                        value: v.reason
+                    }));
+                }
+                if (v.function_name == null || typeof v.function_name !== "string") {
+                    errors.push(JSON.stringify({
+                        path: `$$input[${idx}].function_name`,
+                        expected: "string",
+                        value: v.function_name
+                    }));
+                }
+            }));
+            if (errors.length !== 0) {
+                acc.push({
+                    id: tc.id,
+                    name: tc.function.name,
+                    validation: {
+                        data: tc.function.arguments,
+                        errors
+                    }
+                });
+            }
+        }));
+        return acc;
+    }), []);
+    if (failures.length !== 0) {
+        const feedback = [ ...prevFailures, ...failures ];
+        if (restRetry === 0) {
+            throw new Error(`Failed to select function after ${restRetry} retries\n${JSON.stringify(feedback)}`);
+        }
+        return selectFunction({
+            ctx,
+            toolList,
+            prevFailures: feedback,
+            restRetry: restRetry - 1
+        });
+    }
+    const prompts = [];
+    toolCalls.forEach((v => {
+        v.message.tool_calls.forEach((tc => {
+            const collection = {
+                type: "select",
+                id: tc.id,
+                selections: [],
+                toJSON: () => ({
+                    type: "select",
+                    id: tc.id,
+                    selections: collection.selections.map((s => s.toJSON()))
+                })
+            };
+            const arg = JSON.parse(tc.function.arguments);
+            arg.function_list.forEach((v => {
+                const operation = ctx.operations.flat.get(v.function_name);
+                if (operation === undefined) {
+                    return;
+                }
+                const selection = factory.createOperationSelection({
+                    reason: v.reason,
+                    operation
+                });
+                ctx.stack.push(selection);
+                ctx.dispatch(factory.createSelectEvent({
+                    selection
+                })).catch((() => {}));
+                collection.selections.push(selection);
+            }));
+            prompts.push(collection);
+        }));
+    }));
+    return prompts;
+}
+
+function emendMessages(failures) {
+    return failures.flatMap((f => [ {
+        role: "assistant",
+        tool_calls: [ {
+            type: "function",
+            id: f.id,
+            function: {
+                name: f.name,
+                arguments: JSON.stringify(f.validation.data)
+            }
+        } ]
+    }, {
+        role: "tool",
+        content: JSON.stringify(f.validation.errors),
+        tool_call_id: f.id
+    }, {
+        role: "system",
+        content: [ "You A.I. assistant has composed wrong typed arguments.", "", "Correct it at the next function calling." ].join("\n")
+    } ]));
+}
+
+function uniqBy(array, selector) {
+    const seen = new Set;
+    return array.filter((item => {
+        const key = selector(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    }));
+}
+
+function BootAgenticaVectorSelector(props) {
+    const {isEmbedded, setEmbedded} = useEmbeddedContext();
+    const {searchTool, embedContext} = props.strategy;
+    const selectorExecute = async ctx => {
+        if (!isEmbedded(ctx)) {
+            await embedContext({
+                ctx,
+                setEmbedded: () => setEmbedded(ctx)
+            });
+        }
+        const queries = await extractQuery(ctx);
+        const toolList = await Promise.all(queries.map((async query => searchTool(ctx, query)))).then((res => res.flatMap((output => output.map((v => ({
+            name: v.name,
+            description: v.description
+        }))))).map((v => {
+            const op = ctx.operations.flat.get(v.name);
+            if (op === undefined || op.protocol !== "http") {
+                return v;
+            }
+            return {
+                ...v,
+                method: op.function.method,
+                path: op.function.path,
+                tags: op.function.tags
+            };
+        })))).then((arr => uniqBy(arr, (v => v.name))));
+        if (toolList.length === 0) {
+            return [];
+        }
+        const prompts = await selectFunction({
+            ctx,
+            toolList
+        });
+        return prompts;
+    };
+    return selectorExecute;
+}
+
+function useEmbeddedContext() {
+    const set = new Set;
+    return {
+        isEmbedded: ctx => set.has(JSON.stringify(ctx.operations.array)),
+        setEmbedded: ctx => {
+            set.add(JSON.stringify(ctx.operations.array));
+        }
+    };
+}
+
+export { BootAgenticaVectorSelector, useEmbeddedContext };
+//# sourceMappingURL=index.mjs.map