@agentica/vector-selector 0.20.0

package/lib/utils.js

@@ -0,0 +1,108 @@
+"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.getRetry = getRetry;
+exports.groupByArray = groupByArray;
+exports.uniqBy = uniqBy;
+/**
+ * This function is used to get a retry function.
+ *
+ * It will throw an error if the count is not a number,
+ * or if the count is not a finite number,
+ * or if the count is not an integer,
+ * or if the count is less than 1.
+ *
+ * @param count - The number of times to retry the function.
+ * @returns A retry function.
+ * @throws {TypeError} If the count is not a number, or if the count is not a finite number, or if the count is not an integer, or if the count is less than 1.
+ * @throws {Error} If the function fails to return a value after the specified number of retries.
+ */
+function getRetry(count) {
+    if (count < 1) {
+        throw new Error("count should be greater than 0");
+    }
+    return (fn) => __awaiter(this, void 0, void 0, function* () {
+        let lastError = null;
+        for (let i = 0; i < count; i++) {
+            try {
+                return yield fn();
+            }
+            catch (e) {
+                lastError = e;
+                if (i === count - 1) {
+                    throw e;
+                }
+            }
+        }
+        // count should be greater than 0.
+        throw lastError;
+    });
+}
+/**
+ * This function is used to group an array into a 2-dimensional array.
+ *
+ * It will throw an error if the count is not a number,
+ * or if the count is not a finite number,
+ * or if the count is not an integer,
+ * or if the count is less than 1.
+ *
+ * @param array - The array to group.
+ * @param count - The number of elements in each group.
+ * @returns A 2-dimensional array.
+ */
+function groupByArray(array, count) {
+    if (count < 1) {
+        throw new Error("count should be greater than 0");
+    }
+    if (array.length === 0) {
+        return [];
+    }
+    if (array.length < count) {
+        return [array];
+    }
+    const grouped = [];
+    for (let i = 0; i < array.length; i += count) {
+        grouped.push(array.slice(i, i + count));
+    }
+    return grouped;
+}
+/**
+ * Removes duplicates from an array.
+ * You can specify which value to compare using a property selector function.
+ *
+ * @param array - Array to remove duplicates from
+ * @param selector - Function that selects the value to compare
+ * @returns New array with duplicates removed
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' },
+ *   { id: 1, name: 'John' }
+ * ];
+ *
+ * const uniqueUsers = uniqBy(users, user => user.id);
+ * // Result: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
+ * ```
+ */
+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;
+    });
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;;;;;;;;;AAkBA,4BAsBC;AAcD,oCAkBC;AAsBD,wBAUC;AAnGD;;;;;;;;;;;;GAYG;AACH,SAAgB,QAAQ,CAAwB,KAAqC;IACnF,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,OAAO,CAAU,EAAoB,EAAE,EAAE;QACvC,IAAI,SAAS,GAAY,IAAI,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;YACD,OAAO,CAAU,EAAE,CAAC;gBAClB,SAAS,GAAG,CAAC,CAAC;gBACd,IAAI,CAAC,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC;oBACpB,MAAM,CAAC,CAAC;gBACV,CAAC;YACH,CAAC;QACH,CAAC;QACD,kCAAkC;QAClC,MAAM,SAAS,CAAC;IAClB,CAAC,CAAA,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAA2B,KAAU,EAAE,KAAqC;IACtG,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;QACzB,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED,MAAM,OAAO,GAAG,EAAE,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;QAC7C,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,MAAM,CAAO,KAAU,EAAE,QAAwB;IAC/D,MAAM,IAAI,GAAG,IAAI,GAAG,EAAK,CAAC;IAC1B,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QAC3B,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC"}

package/lib/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@agentica/vector-selector",
+  "version": "0.20.0",
+  "author": "Wrtn Technologies",
+  "license": "MIT",
+  "homepage": "https://wrtnlabs.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wrtnlabs/agentica"
+  },
+  "bugs": {
+    "url": "https://github.com/wrtnlabs/agent/issues"
+  },
+  "keywords": [
+    "openai",
+    "chatgpt",
+    "anthropic",
+    "claude",
+    "ai",
+    "chatbot",
+    "nestia",
+    "swagger",
+    "openapi"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.mjs"
+    },
+    "./strategy": {
+      "types": "./lib/strategy/index.d.ts",
+      "require": "./lib/strategy/index.js",
+      "default": "./lib/strategy/index.mjs"
+    }
+  },
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib",
+    "package.json",
+    "prompts",
+    "src"
+  ],
+  "peerDependencies": {
+    "@agentica/core": "^0.20.0"
+  },
+  "dependencies": {
+    "@wrtnlabs/connector-hive-api": "^1.5.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "@samchon/openapi": "^4.2.0",
+    "@types/node": "^22.10.5",
+    "json-schema-to-ts": "^3.1.1",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.29.1",
+    "type-fest": "^4.37.0",
+    "typescript": "~5.8.3",
+    "vitest": "^3.0.9",
+    "@agentica/core": "^0.20.0"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json && rollup -c",
+    "lint": "eslint .",
+    "format": "eslint --fix .",
+    "test": "vitest"
+  },
+  "module": "lib/index.mjs",
+  "typings": "lib/index.d.ts"
+}

package/src/extract_query.ts

@@ -0,0 +1,47 @@
+import type { AgenticaContext } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+import type { FromSchema } from "json-schema-to-ts";
+
+import { factory, utils } from "@agentica/core";
+
+import { Tools } from "./tools";
+
+export async function extractQuery<SchemaModel extends ILlmSchema.Model>(ctx: AgenticaContext<SchemaModel>) {
+  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<SchemaModel>)
+        .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) as Partial<FromSchema<typeof Tools.extract_query.function.parameters>>;
+    if (!Array.isArray(arg.query_list)) {
+      return [];
+    }
+
+    return arg.query_list.map(v => v.query);
+  }) ?? [];
+
+  return queries;
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+import type { AgenticaContext, AgenticaHistory } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+
+import { extractQuery } from "./extract_query";
+import { selectFunction } from "./select";
+import { uniqBy } from "./utils";
+
+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 function BootAgenticaVectorSelector<SchemaModel extends ILlmSchema.Model>(props: IAgenticaVectorSelectorBootProps<SchemaModel>) {
+  const { isEmbedded, setEmbedded } = useEmbeddedContext<SchemaModel>();
+  const { searchTool, embedContext } = props.strategy;
+  const selectorExecute = async (
+    ctx: AgenticaContext<SchemaModel>,
+  ): Promise<AgenticaHistory<SchemaModel>[]> => {
+    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;
+}
+
+export function useEmbeddedContext<SchemaModel extends ILlmSchema.Model>() {
+  const set = new Set<string>();
+  return {
+    isEmbedded: (ctx: AgenticaContext<SchemaModel>) =>
+      set.has(JSON.stringify(ctx.operations.array)),
+    setEmbedded: (ctx: AgenticaContext<SchemaModel>) => {
+      set.add(JSON.stringify(ctx.operations.array));
+    },
+  } as const;
+}

package/src/select.ts

@@ -0,0 +1,217 @@
+import type { AgenticaContext, AgenticaOperationSelection, AgenticaSelectHistory } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+
+import { factory, utils } from "@agentica/core";
+import { AgenticaDefaultPrompt } from "@agentica/core/src/constants/AgenticaDefaultPrompt";
+import { AgenticaSystemPrompt } from "@agentica/core/src/constants/AgenticaSystemPrompt";
+
+import { Tools } from "./tools";
+
+interface IFailure {
+  id: string;
+  name: string;
+  validation: {
+    data: string;
+    errors: string[];
+  };
+}
+
+export async function selectFunction<SchemaModel extends ILlmSchema.Model>(props: {
+  ctx: AgenticaContext<SchemaModel>;
+  toolList: object[];
+  prevFailures?: IFailure[];
+  restRetry?: number;
+}) {
+  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<SchemaModel>),
+      {
+        role: "user",
+        content: ctx.prompt.text,
+      },
+      {
+        role: "system",
+        content: `${ctx.config?.systemPrompt?.select?.(ctx.histories)
+        ?? AgenticaSystemPrompt.SELECT}
+          
+        
+        When selecting functions, consider what the user can call from their perspective, and choose all the functions necessary to accomplish the task.
+        Select them in a logical sequence, taking into account the relationships between each function.
+        `,
+      },
+      ...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<IFailure[]>((acc, cur) => {
+    cur.message.tool_calls?.forEach((tc) => {
+      const errors: string[] = [];
+      const arg = JSON.parse(tc.function.arguments) as Partial<{ reason: string; function_name: string }>[];
+      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: AgenticaSelectHistory<SchemaModel>[] = [];
+  toolCalls.forEach((v) => {
+    v.message.tool_calls!.forEach((tc) => {
+      const collection: AgenticaSelectHistory<SchemaModel> = {
+        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) as {
+        function_list: {
+          reason: string;
+          function_name: string;
+        }[];
+      };
+      arg.function_list.forEach((v) => {
+        const operation = ctx.operations.flat.get(v.function_name);
+
+        if (operation === undefined) {
+          return;
+        }
+        const selection: AgenticaOperationSelection<SchemaModel>
+          = 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<SchemaModel extends ILlmSchema.Model>(failures: IFailure[]): ReturnType<typeof factory.decodeHistory<SchemaModel>> {
+  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"),
+      },
+    ]) satisfies ReturnType<typeof factory.decodeHistory<SchemaModel>>;
+}

package/src/strategy/index.ts

@@ -0,0 +1 @@
+export * from "./postgres.strategy";

package/src/strategy/postgres.strategy.ts

@@ -0,0 +1,117 @@
+import type { AgenticaContext, AgenticaOperation } from "@agentica/core";
+import type { ILlmSchema } from "@samchon/openapi";
+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<SchemaModel extends ILlmSchema.Model>(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy<SchemaModel>["searchTool"] {
+  return async (ctx: AgenticaContext<SchemaModel>, 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 <SchemaModel extends ILlmSchema.Model>(
+    controllerName: string,
+    opList: AgenticaOperation<SchemaModel>[],
+  ) => {
+    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<SchemaModel extends ILlmSchema.Model>(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy<SchemaModel>["embedContext"] {
+  return async (props: { ctx: AgenticaContext<SchemaModel>; 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<SchemaModel>>,
+        ]) => {
+          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<SchemaModel extends ILlmSchema.Model>(connection: IConnection<object | undefined>): IAgenticaVectorSelectorStrategy<SchemaModel> {
+  return {
+    searchTool: searchTool(connection),
+    embedContext: embedContext(connection),
+  };
+}