@agentica/core 0.44.0-dev.20260313 → 0.44.0

package/src/utils/StreamUtil.ts

@@ -1,87 +1,87 @@
-/**
- * @module StreamUtil
- *
- * Utility functions for streams.
- */
-
-async function readAll<T>(stream: ReadableStream<T>, abortSignal?: AbortSignal): Promise<T[]> {
-  const reader = stream.getReader();
-  const result: T[] = [];
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done || abortSignal?.aborted === true) {
-      break;
-    }
-    result.push(value);
-  }
-  return result;
-}
-
-async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, options: { initial?: R; abortSignal?: AbortSignal }): Promise<R | null> {
-  const reader = stream.getReader();
-  const iterator = streamDefaultReaderToAsyncGenerator(reader);
-  let acc = (options.initial ?? null) as R | null | T;
-
-  for await (const value of iterator) {
-    if (options.abortSignal?.aborted === true) {
-      break;
-    }
-
-    if (acc === null) {
-      acc = value;
-      continue;
-    }
-
-    acc = reducer(acc, value);
-  }
-
-  return acc as R;
-}
-
-function from<T>(...value: T[]): ReadableStream<T> {
-  const stream = new ReadableStream<T>({
-    start: (controller) => {
-      value.forEach(v => controller.enqueue(v));
-      controller.close();
-    },
-  });
-
-  return stream;
-}
-
-export async function* toAsyncGenerator<T>(value: T): AsyncGenerator<T, undefined, undefined> {
-  yield value;
-}
-
-export async function* streamDefaultReaderToAsyncGenerator<T>(reader: ReadableStreamDefaultReader<T>, abortSignal?: AbortSignal): AsyncGenerator<Awaited<T>, undefined, undefined> {
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done || abortSignal?.aborted === true) {
-      break;
-    }
-    yield value;
-  }
-}
-
-function transform<T, R>(stream: ReadableStream<T>, transformer: (value: T) => R, abortSignal?: AbortSignal): ReadableStream<R> {
-  const reader = stream.getReader();
-
-  return new ReadableStream<R>({
-    pull: async (controller) => {
-      const { done, value } = await reader.read();
-      if (done === true || abortSignal?.aborted === true) {
-        controller.close();
-        return;
-      }
-
-      controller.enqueue(transformer(value));
-    },
-  });
-}
-
-export const StreamUtil = {
-  readAll,
-  reduce,
-  from,
-  transform,
-};
+/**
+ * @module StreamUtil
+ *
+ * Utility functions for streams.
+ */
+
+async function readAll<T>(stream: ReadableStream<T>, abortSignal?: AbortSignal): Promise<T[]> {
+  const reader = stream.getReader();
+  const result: T[] = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done || abortSignal?.aborted === true) {
+      break;
+    }
+    result.push(value);
+  }
+  return result;
+}
+
+async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, options: { initial?: R; abortSignal?: AbortSignal }): Promise<R | null> {
+  const reader = stream.getReader();
+  const iterator = streamDefaultReaderToAsyncGenerator(reader);
+  let acc = (options.initial ?? null) as R | null | T;
+
+  for await (const value of iterator) {
+    if (options.abortSignal?.aborted === true) {
+      break;
+    }
+
+    if (acc === null) {
+      acc = value;
+      continue;
+    }
+
+    acc = reducer(acc, value);
+  }
+
+  return acc as R;
+}
+
+function from<T>(...value: T[]): ReadableStream<T> {
+  const stream = new ReadableStream<T>({
+    start: (controller) => {
+      value.forEach(v => controller.enqueue(v));
+      controller.close();
+    },
+  });
+
+  return stream;
+}
+
+export async function* toAsyncGenerator<T>(value: T): AsyncGenerator<T, undefined, undefined> {
+  yield value;
+}
+
+export async function* streamDefaultReaderToAsyncGenerator<T>(reader: ReadableStreamDefaultReader<T>, abortSignal?: AbortSignal): AsyncGenerator<Awaited<T>, undefined, undefined> {
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done || abortSignal?.aborted === true) {
+      break;
+    }
+    yield value;
+  }
+}
+
+function transform<T, R>(stream: ReadableStream<T>, transformer: (value: T) => R, abortSignal?: AbortSignal): ReadableStream<R> {
+  const reader = stream.getReader();
+
+  return new ReadableStream<R>({
+    pull: async (controller) => {
+      const { done, value } = await reader.read();
+      if (done === true || abortSignal?.aborted === true) {
+        controller.close();
+        return;
+      }
+
+      controller.enqueue(transformer(value));
+    },
+  });
+}
+
+export const StreamUtil = {
+  readAll,
+  reduce,
+  from,
+  transform,
+};

package/src/utils/__map_take.spec.ts

@@ -1,140 +1,140 @@
-import { __map_take } from "./__map_take";
-
-describe("__map_take", () => {
-  describe("basic functionality", () => {
-    it("should generate value for new key", () => {
-      const map = new Map<string, number>();
-      const generator = () => 42;
-
-      const result = __map_take(map, "test", generator);
-
-      expect(result).toBe(42);
-      expect(map.get("test")).toBe(42);
-    });
-
-    it("should return existing value for existing key", () => {
-      const map = new Map<string, number>();
-      map.set("test", 100);
-
-      const generator = () => 42;
-      const result = __map_take(map, "test", generator);
-
-      expect(result).toBe(100);
-      expect(map.get("test")).toBe(100);
-    });
-  });
-
-  describe("various type tests", () => {
-    it("should handle object type", () => {
-      const map = new Map<string, { value: number }>();
-      const generator = () => ({ value: 42 });
-
-      const result = __map_take(map, "test", generator);
-
-      expect(result).toEqual({ value: 42 });
-      expect(map.get("test")).toEqual({ value: 42 });
-    });
-
-    it("should handle array type", () => {
-      const map = new Map<string, number[]>();
-      const generator = () => [1, 2, 3];
-
-      const result = __map_take(map, "test", generator);
-
-      expect(result).toEqual([1, 2, 3]);
-      expect(map.get("test")).toEqual([1, 2, 3]);
-    });
-
-    it("should handle function type", () => {
-      const map = new Map<string, () => number>();
-      const generator = () => () => 42;
-
-      const result = __map_take(map, "test", generator);
-
-      expect(result()).toBe(42);
-      expect(map.get("test")?.()).toBe(42);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle null key", () => {
-      const map = new Map<null, string>();
-      const generator = () => "test";
-
-      const result = __map_take(map, null, generator);
-
-      expect(result).toBe("test");
-      expect(map.get(null)).toBe("test");
-    });
-
-    it("should handle undefined key", () => {
-      const map = new Map<undefined, string>();
-      const generator = () => "test";
-
-      const result = __map_take(map, undefined, generator);
-
-      expect(result).toBe("test");
-      expect(map.get(undefined)).toBe("test");
-    });
-
-    it("should handle empty string key", () => {
-      const map = new Map<string, string>();
-      const generator = () => "test";
-
-      const result = __map_take(map, "", generator);
-
-      expect(result).toBe("test");
-      expect(map.get("")).toBe("test");
-    });
-  });
-
-  describe("generator function tests", () => {
-    it("should not call generator multiple times", () => {
-      const map = new Map<string, number>();
-      let callCount = 0;
-
-      const generator = () => {
-        callCount++;
-        return 42;
-      };
-
-      __map_take(map, "test", generator);
-      __map_take(map, "test", generator);
-
-      expect(callCount).toBe(1);
-    });
-
-    it("should handle generator throwing error", () => {
-      const map = new Map<string, number>();
-      const generator = () => {
-        throw new Error("Generator error");
-      };
-
-      expect(() => __map_take(map, "test", generator)).toThrow("Generator error");
-    });
-
-    it("should handle generator returning undefined", () => {
-      const map = new Map<string, undefined>();
-      const generator = () => undefined;
-
-      const result = __map_take(map, "test", generator);
-
-      expect(result).toBeUndefined();
-      expect(map.get("test")).toBeUndefined();
-    });
-  });
-
-  describe("concurrency tests", () => {
-    it("should handle concurrent access to same key", () => {
-      const map = new Map<string, number>();
-      const generator = () => 42;
-
-      const result1 = __map_take(map, "test", generator);
-      const result2 = __map_take(map, "test", generator);
-
-      expect(result1).toBe(42);
-      expect(result2).toBe(42);
-      expect(map.get("test")).toBe(42);
-    });
-  });
-});
+import { __map_take } from "./__map_take";
+
+describe("__map_take", () => {
+  describe("basic functionality", () => {
+    it("should generate value for new key", () => {
+      const map = new Map<string, number>();
+      const generator = () => 42;
+
+      const result = __map_take(map, "test", generator);
+
+      expect(result).toBe(42);
+      expect(map.get("test")).toBe(42);
+    });
+
+    it("should return existing value for existing key", () => {
+      const map = new Map<string, number>();
+      map.set("test", 100);
+
+      const generator = () => 42;
+      const result = __map_take(map, "test", generator);
+
+      expect(result).toBe(100);
+      expect(map.get("test")).toBe(100);
+    });
+  });
+
+  describe("various type tests", () => {
+    it("should handle object type", () => {
+      const map = new Map<string, { value: number }>();
+      const generator = () => ({ value: 42 });
+
+      const result = __map_take(map, "test", generator);
+
+      expect(result).toEqual({ value: 42 });
+      expect(map.get("test")).toEqual({ value: 42 });
+    });
+
+    it("should handle array type", () => {
+      const map = new Map<string, number[]>();
+      const generator = () => [1, 2, 3];
+
+      const result = __map_take(map, "test", generator);
+
+      expect(result).toEqual([1, 2, 3]);
+      expect(map.get("test")).toEqual([1, 2, 3]);
+    });
+
+    it("should handle function type", () => {
+      const map = new Map<string, () => number>();
+      const generator = () => () => 42;
+
+      const result = __map_take(map, "test", generator);
+
+      expect(result()).toBe(42);
+      expect(map.get("test")?.()).toBe(42);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle null key", () => {
+      const map = new Map<null, string>();
+      const generator = () => "test";
+
+      const result = __map_take(map, null, generator);
+
+      expect(result).toBe("test");
+      expect(map.get(null)).toBe("test");
+    });
+
+    it("should handle undefined key", () => {
+      const map = new Map<undefined, string>();
+      const generator = () => "test";
+
+      const result = __map_take(map, undefined, generator);
+
+      expect(result).toBe("test");
+      expect(map.get(undefined)).toBe("test");
+    });
+
+    it("should handle empty string key", () => {
+      const map = new Map<string, string>();
+      const generator = () => "test";
+
+      const result = __map_take(map, "", generator);
+
+      expect(result).toBe("test");
+      expect(map.get("")).toBe("test");
+    });
+  });
+
+  describe("generator function tests", () => {
+    it("should not call generator multiple times", () => {
+      const map = new Map<string, number>();
+      let callCount = 0;
+
+      const generator = () => {
+        callCount++;
+        return 42;
+      };
+
+      __map_take(map, "test", generator);
+      __map_take(map, "test", generator);
+
+      expect(callCount).toBe(1);
+    });
+
+    it("should handle generator throwing error", () => {
+      const map = new Map<string, number>();
+      const generator = () => {
+        throw new Error("Generator error");
+      };
+
+      expect(() => __map_take(map, "test", generator)).toThrow("Generator error");
+    });
+
+    it("should handle generator returning undefined", () => {
+      const map = new Map<string, undefined>();
+      const generator = () => undefined;
+
+      const result = __map_take(map, "test", generator);
+
+      expect(result).toBeUndefined();
+      expect(map.get("test")).toBeUndefined();
+    });
+  });
+
+  describe("concurrency tests", () => {
+    it("should handle concurrent access to same key", () => {
+      const map = new Map<string, number>();
+      const generator = () => 42;
+
+      const result1 = __map_take(map, "test", generator);
+      const result2 = __map_take(map, "test", generator);
+
+      expect(result1).toBe(42);
+      expect(result2).toBe(42);
+      expect(map.get("test")).toBe(42);
+    });
+  });
+});

package/src/utils/__map_take.ts

@@ -1,13 +1,13 @@
-/**
- * @internal
- */
-export function __map_take<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;
-}
+/**
+ * @internal
+ */
+export function __map_take<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;
+}