@autobe/agent 0.30.0-dev.20260315 → 0.30.0

package/src/utils/emplaceMap.ts

@@ -1,31 +1,31 @@
-/**
- * Gets existing value from Map or lazily creates it if missing.
- *
- * Implements the lazy initialization pattern: returns existing value if key
- * exists, otherwise calls generator function to create new value, stores it,
- * and returns it. Ensures generator is only called when necessary, avoiding
- * wasteful computation.
- *
- * Used throughout AutoBE for caching event listeners, validation state, and
- * other expensive-to-create objects that should be initialized on first
- * access.
- *
- * @param dict Map to query and potentially update
- * @param key Key to look up or create
- * @param generator Function to create value if key doesn't exist
- * @returns Existing or newly created value
- */
-export function emplaceMap<Key, T>(
-  dict: Map<Key, T>,
-  key: Key,
-  generator: () => T,
-): T {
-  const oldbie: T | undefined = dict.get(key);
-  if (oldbie !== undefined) {
-    return oldbie;
-  }
-
-  const value: T = generator();
-  dict.set(key, value);
-  return value;
-}
+/**
+ * Gets existing value from Map or lazily creates it if missing.
+ *
+ * Implements the lazy initialization pattern: returns existing value if key
+ * exists, otherwise calls generator function to create new value, stores it,
+ * and returns it. Ensures generator is only called when necessary, avoiding
+ * wasteful computation.
+ *
+ * Used throughout AutoBE for caching event listeners, validation state, and
+ * other expensive-to-create objects that should be initialized on first
+ * access.
+ *
+ * @param dict Map to query and potentially update
+ * @param key Key to look up or create
+ * @param generator Function to create value if key doesn't exist
+ * @returns Existing or newly created value
+ */
+export function emplaceMap<Key, T>(
+  dict: Map<Key, T>,
+  key: Key,
+  generator: () => T,
+): T {
+  const oldbie: T | undefined = dict.get(key);
+  if (oldbie !== undefined) {
+    return oldbie;
+  }
+
+  const value: T = generator();
+  dict.set(key, value);
+  return value;
+}

package/src/utils/executeCachedBatch.ts

@@ -1,67 +1,67 @@
-import { Pair, Semaphore } from "tstl";
-import { v7 } from "uuid";
-
-import { AutoBeConfigConstant } from "../constants/AutoBeConfigConstant";
-import { AutoBeContext } from "../context/AutoBeContext";
-
-/**
- * Executes task list with semaphore-controlled parallelization.
- *
- * All tasks are dispatched immediately into a worker pool, with concurrency
- * limited by the semaphore to prevent overwhelming LLM APIs. Results are
- * returned in original order.
- *
- * @param ctx Execution context providing vendor semaphore configuration
- * @param taskList List of async tasks to execute, each receiving cache key
- * @param promptCacheKey Optional cache key (generates UUID if not provided)
- * @returns Array of task results in original order
- */
-export const executeCachedBatch = async <T>(
-  ctx: AutoBeContext | number,
-  taskList: Task<T>[],
-  promptCacheKey?: string,
-): Promise<T[]> => {
-  if (taskList.length === 0) return [];
-
-  promptCacheKey ??= v7();
-  const semaphore: number =
-    typeof ctx === "number"
-      ? ctx
-      : ctx.vendor.semaphore && ctx.vendor.semaphore instanceof Semaphore
-        ? ctx.vendor.semaphore.max()
-        : (ctx.vendor.semaphore ?? AutoBeConfigConstant.SEMAPHORE);
-
-  const queue: Array<Pair<Task<T>, number>> = taskList.map(
-    (task, index) => new Pair(task, index),
-  );
-  const results: Pair<T, number>[] = [];
-  let aborted: boolean = false;
-  let firstError: unknown = null;
-  await Promise.allSettled(
-    new Array(Math.min(semaphore, queue.length)).fill(0).map(async () => {
-      while (queue.length !== 0 && !aborted) {
-        const item: Pair<Task<T>, number> = queue.splice(0, 1)[0]!;
-        try {
-          const result: T = await item.first(promptCacheKey!);
-          if (!aborted) results.push(new Pair(result, item.second));
-        } catch (error) {
-          if (!aborted) {
-            aborted = true;
-            queue.length = 0;
-            firstError = error;
-          }
-        }
-      }
-    }),
-  );
-  if (firstError !== null) throw firstError;
-  return results.sort((x, y) => x.second - y.second).map((p) => p.first);
-};
-
-/**
- * Task function that receives cache key and returns result.
- *
- * The cache key (typically UUID) is used as user message to trigger prompt
- * cache reuse across multiple LLM API calls with identical system prompts.
- */
-type Task<T> = (user: string) => Promise<T>;
+import { Pair, Semaphore } from "tstl";
+import { v7 } from "uuid";
+
+import { AutoBeConfigConstant } from "../constants/AutoBeConfigConstant";
+import { AutoBeContext } from "../context/AutoBeContext";
+
+/**
+ * Executes task list with semaphore-controlled parallelization.
+ *
+ * All tasks are dispatched immediately into a worker pool, with concurrency
+ * limited by the semaphore to prevent overwhelming LLM APIs. Results are
+ * returned in original order.
+ *
+ * @param ctx Execution context providing vendor semaphore configuration
+ * @param taskList List of async tasks to execute, each receiving cache key
+ * @param promptCacheKey Optional cache key (generates UUID if not provided)
+ * @returns Array of task results in original order
+ */
+export const executeCachedBatch = async <T>(
+  ctx: AutoBeContext | number,
+  taskList: Task<T>[],
+  promptCacheKey?: string,
+): Promise<T[]> => {
+  if (taskList.length === 0) return [];
+
+  promptCacheKey ??= v7();
+  const semaphore: number =
+    typeof ctx === "number"
+      ? ctx
+      : ctx.vendor.semaphore && ctx.vendor.semaphore instanceof Semaphore
+        ? ctx.vendor.semaphore.max()
+        : (ctx.vendor.semaphore ?? AutoBeConfigConstant.SEMAPHORE);
+
+  const queue: Array<Pair<Task<T>, number>> = taskList.map(
+    (task, index) => new Pair(task, index),
+  );
+  const results: Pair<T, number>[] = [];
+  let aborted: boolean = false;
+  let firstError: unknown = null;
+  await Promise.allSettled(
+    new Array(Math.min(semaphore, queue.length)).fill(0).map(async () => {
+      while (queue.length !== 0 && !aborted) {
+        const item: Pair<Task<T>, number> = queue.splice(0, 1)[0]!;
+        try {
+          const result: T = await item.first(promptCacheKey!);
+          if (!aborted) results.push(new Pair(result, item.second));
+        } catch (error) {
+          if (!aborted) {
+            aborted = true;
+            queue.length = 0;
+            firstError = error;
+          }
+        }
+      }
+    }),
+  );
+  if (firstError !== null) throw firstError;
+  return results.sort((x, y) => x.second - y.second).map((p) => p.first);
+};
+
+/**
+ * Task function that receives cache key and returns result.
+ *
+ * The cache key (typically UUID) is used as user message to trigger prompt
+ * cache reuse across multiple LLM API calls with identical system prompts.
+ */
+type Task<T> = (user: string) => Promise<T>;

package/src/utils/forceRetry.ts

@@ -1,15 +1,15 @@
-export const forceRetry = async <T>(
-  task: () => Promise<T>,
-  count: number = 3,
-  predicate?: (error: unknown) => boolean,
-): Promise<T> => {
-  let error: unknown = undefined;
-  for (let i: number = 0; i < count; ++i)
-    try {
-      return await task();
-    } catch (e) {
-      if (predicate?.(e) === false) throw e;
-      error = e;
-    }
-  throw error;
-};
+export const forceRetry = async <T>(
+  task: () => Promise<T>,
+  count: number = 3,
+  predicate?: (error: unknown) => boolean,
+): Promise<T> => {
+  let error: unknown = undefined;
+  for (let i: number = 0; i < count; ++i)
+    try {
+      return await task();
+    } catch (e) {
+      if (predicate?.(e) === false) throw e;
+      error = e;
+    }
+  throw error;
+};

package/src/utils/getEmbedder.ts

@@ -1,16 +1,16 @@
-// local embedding
-import { LocalEmbeddingProvider } from "./LocalEmbeddingProvider";
-
-let _embedder: LocalEmbeddingProvider | null = null;
-
-export function getEmbedder(): LocalEmbeddingProvider {
-  if (!_embedder) {
-    _embedder = new LocalEmbeddingProvider({
-      modelIdOrPath: "Xenova/all-MiniLM-L6-v2",
-      quantized: true,
-      batchSize: 32,
-      enableCache: true,
-    });
-  }
-  return _embedder;
-}
+// local embedding
+import { LocalEmbeddingProvider } from "./LocalEmbeddingProvider";
+
+let _embedder: LocalEmbeddingProvider | null = null;
+
+export function getEmbedder(): LocalEmbeddingProvider {
+  if (!_embedder) {
+    _embedder = new LocalEmbeddingProvider({
+      modelIdOrPath: "Xenova/all-MiniLM-L6-v2",
+      quantized: true,
+      batchSize: 32,
+      enableCache: true,
+    });
+  }
+  return _embedder;
+}