@anvia/core 1.1.2 → 1.2.0

package/dist/chunk-ETYB5JO6.js

@@ -0,0 +1,175 @@
+import {
+  PipelineObserverDispatchError
+} from "./chunk-R6722CIU.js";
+import {
+  observerSnapshot
+} from "./chunk-H3H74RWJ.js";
+
+// src/pipeline/observability.ts
+function resolvePrimaryTrace(observers, primaryTrace) {
+  if (primaryTrace === void 0) return void 0;
+  const primary = observers.find((entry) => entry.name === primaryTrace);
+  return primary?.observer.trace === void 0 ? void 0 : Object.freeze({ observer: primary.name, ...primary.observer.trace });
+}
+function snapshotPipelineObservability(observability) {
+  if (observability === void 0) return void 0;
+  const observers = {};
+  for (const [name, observer] of Object.entries(observability.observers)) {
+    if (name.trim().length === 0) {
+      throw new TypeError("Pipeline observer names must not be empty.");
+    }
+    if (typeof observer !== "object" || observer === null || typeof observer.startRun !== "function") {
+      throw new TypeError(`Pipeline observer "${name}" must implement startRun().`);
+    }
+    observers[name] = observer;
+  }
+  if (observability.primaryTrace !== void 0 && !(observability.primaryTrace in observers)) {
+    throw new TypeError(
+      `Pipeline primaryTrace "${observability.primaryTrace}" must name a configured observer.`
+    );
+  }
+  const errorPolicy = observability.errorPolicy ?? "ignore";
+  if (errorPolicy !== "ignore" && errorPolicy !== "throw") {
+    throw new TypeError('Pipeline observability.errorPolicy must be "ignore" or "throw".');
+  }
+  const snapshot = {
+    observers: Object.freeze(observers),
+    errorPolicy,
+    ...observability.primaryTrace === void 0 ? {} : { primaryTrace: observability.primaryTrace }
+  };
+  return Object.freeze(snapshot);
+}
+async function startPipelineRunObservers(observers, args, options) {
+  const runObservers = [];
+  const failures = [];
+  for (const [name, observer] of Object.entries(observers)) {
+    try {
+      const runObserver = await observer.startRun(observerSnapshot(args));
+      if (runObserver !== void 0) {
+        runObservers.push({ name, observer: runObserver, terminal: false });
+      }
+    } catch (error) {
+      failures.push({ observer: name, error });
+    }
+  }
+  if (options.errorPolicy === "throw" && failures.length > 0) {
+    const startupError = new PipelineObserverDispatchError("startRun", failures);
+    const cleanupFailures = await terminateObservers(
+      runObservers,
+      (observer) => observer.error?.(
+        observerSnapshot({
+          runId: args.runId,
+          pipelineId: args.pipelineId,
+          status: "failed",
+          error: startupError,
+          durationMs: 0
+        })
+      )
+    );
+    throw new PipelineObserverDispatchError("startRun", [...failures, ...cleanupFailures]);
+  }
+  return new ActivePipelineRunObservers(runObservers, options);
+}
+var ActivePipelineRunObservers = class {
+  constructor(observers, options) {
+    this.observers = observers;
+    this.options = options;
+    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);
+  }
+  observers;
+  options;
+  trace;
+  async startStage(args) {
+    const stageObservers = [];
+    const failures = [];
+    for (const entry of this.observers) {
+      if (entry.observer.startStage === void 0) continue;
+      try {
+        const observer = await entry.observer.startStage(observerSnapshot(args));
+        if (observer !== void 0) {
+          stageObservers.push({ name: entry.name, observer, terminal: false });
+        }
+      } catch (error) {
+        failures.push({ observer: entry.name, error });
+      }
+    }
+    if (this.options.errorPolicy === "throw" && failures.length > 0) {
+      const startupError = new PipelineObserverDispatchError("startStage", failures);
+      const cleanupFailures = await terminateObservers(
+        stageObservers,
+        (observer) => observer.error?.(observerSnapshot({ ...args, error: startupError, durationMs: 0 }))
+      );
+      throw new PipelineObserverDispatchError("startStage", [...failures, ...cleanupFailures]);
+    }
+    return new ActivePipelineStageObservers(stageObservers, this.options);
+  }
+  async end(args) {
+    await dispatchTerminalObservers(
+      this.observers,
+      "end",
+      (observer) => observer.end(observerSnapshot(args)),
+      this.options.errorPolicy
+    );
+  }
+  async error(args) {
+    await dispatchTerminalObservers(
+      this.observers,
+      "error",
+      (observer) => observer.error?.(observerSnapshot(args)),
+      "ignore"
+    );
+  }
+};
+var ActivePipelineStageObservers = class {
+  constructor(observers, options) {
+    this.observers = observers;
+    this.options = options;
+    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);
+  }
+  observers;
+  options;
+  trace;
+  async end(args) {
+    await dispatchTerminalObservers(
+      this.observers,
+      "stage.end",
+      (observer) => observer.end(observerSnapshot(args)),
+      this.options.errorPolicy
+    );
+  }
+  async error(args) {
+    await dispatchTerminalObservers(
+      this.observers,
+      "stage.error",
+      (observer) => observer.error?.(observerSnapshot(args)),
+      "ignore"
+    );
+  }
+};
+async function dispatchTerminalObservers(observers, phase, dispatch, errorPolicy) {
+  const failures = await terminateObservers(observers, dispatch);
+  if (errorPolicy === "throw" && failures.length > 0) {
+    throw new PipelineObserverDispatchError(phase, failures);
+  }
+}
+async function terminateObservers(observers, dispatch) {
+  const failures = [];
+  for (const entry of observers) {
+    if (entry.terminal) continue;
+    entry.terminal = true;
+    try {
+      await dispatch(entry.observer);
+    } catch (error) {
+      failures.push({ observer: entry.name, error });
+    }
+  }
+  return failures;
+}
+
+export {
+  snapshotPipelineObservability,
+  startPipelineRunObservers,
+  ActivePipelineRunObservers,
+  ActivePipelineStageObservers
+};
+//# sourceMappingURL=chunk-ETYB5JO6.js.map

package/dist/chunk-ETYB5JO6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipeline/observability.ts"],"sourcesContent":["import { observerSnapshot } from \"../observability/snapshot\";\nimport { PipelineObserverDispatchError, type PipelineObserverFailure } from \"./errors\";\nimport type {\n  PipelineObservabilityOptions,\n  PipelineObserverErrorPolicy,\n  PipelineObserverMap,\n  PipelineObserverTraceInfo,\n  PipelineRunEndArgs,\n  PipelineRunErrorArgs,\n  PipelineRunObservation,\n  PipelineRunStartArgs,\n  PipelineStageEndArgs,\n  PipelineStageErrorArgs,\n  PipelineStageObservation,\n  PipelineStageStartArgs,\n  PipelineTraceInfo,\n} from \"./types\";\n\ntype NamedObserver<T> = {\n  readonly name: string;\n  readonly observer: T;\n};\n\ntype ActiveNamedObserver<T> = NamedObserver<T> & {\n  terminal: boolean;\n};\n\nfunction resolvePrimaryTrace<T extends { readonly trace?: PipelineObserverTraceInfo | undefined }>(\n  observers: readonly ActiveNamedObserver<T>[],\n  primaryTrace: string | undefined,\n): PipelineTraceInfo | undefined {\n  if (primaryTrace === undefined) return undefined;\n  const primary = observers.find((entry) => entry.name === primaryTrace);\n  return primary?.observer.trace === undefined\n    ? undefined\n    : Object.freeze({ observer: primary.name, ...primary.observer.trace });\n}\n\nexport function snapshotPipelineObservability(\n  observability: PipelineObservabilityOptions | undefined,\n): PipelineObservabilityOptions | undefined {\n  if (observability === undefined) return undefined;\n  const observers: Record<string, PipelineObserverMap[string]> = {};\n  for (const [name, observer] of Object.entries(observability.observers)) {\n    if (name.trim().length === 0) {\n      throw new TypeError(\"Pipeline observer names must not be empty.\");\n    }\n    if (\n      typeof observer !== \"object\" ||\n      observer === null ||\n      typeof observer.startRun !== \"function\"\n    ) {\n      throw new TypeError(`Pipeline observer \"${name}\" must implement startRun().`);\n    }\n    observers[name] = observer;\n  }\n  if (observability.primaryTrace !== undefined && !(observability.primaryTrace in observers)) {\n    throw new TypeError(\n      `Pipeline primaryTrace \"${observability.primaryTrace}\" must name a configured observer.`,\n    );\n  }\n  const errorPolicy = observability.errorPolicy ?? \"ignore\";\n  if (errorPolicy !== \"ignore\" && errorPolicy !== \"throw\") {\n    throw new TypeError('Pipeline observability.errorPolicy must be \"ignore\" or \"throw\".');\n  }\n  const snapshot: PipelineObservabilityOptions = {\n    observers: Object.freeze(observers),\n    errorPolicy,\n    ...(observability.primaryTrace === undefined\n      ? {}\n      : { primaryTrace: observability.primaryTrace }),\n  };\n  return Object.freeze(snapshot);\n}\n\nexport async function startPipelineRunObservers(\n  observers: PipelineObserverMap,\n  args: PipelineRunStartArgs,\n  options: {\n    readonly primaryTrace?: string | undefined;\n    readonly errorPolicy: PipelineObserverErrorPolicy;\n  },\n): Promise<ActivePipelineRunObservers> {\n  const runObservers: ActiveNamedObserver<PipelineRunObservation>[] = [];\n  const failures: PipelineObserverFailure[] = [];\n  for (const [name, observer] of Object.entries(observers)) {\n    try {\n      const runObserver = await observer.startRun(observerSnapshot(args));\n      if (runObserver !== undefined) {\n        runObservers.push({ name, observer: runObserver, terminal: false });\n      }\n    } catch (error) {\n      failures.push({ observer: name, error });\n    }\n  }\n  if (options.errorPolicy === \"throw\" && failures.length > 0) {\n    const startupError = new PipelineObserverDispatchError(\"startRun\", failures);\n    const cleanupFailures = await terminateObservers(runObservers, (observer) =>\n      observer.error?.(\n        observerSnapshot({\n          runId: args.runId,\n          pipelineId: args.pipelineId,\n          status: \"failed\",\n          error: startupError,\n          durationMs: 0,\n        }),\n      ),\n    );\n    throw new PipelineObserverDispatchError(\"startRun\", [...failures, ...cleanupFailures]);\n  }\n  return new ActivePipelineRunObservers(runObservers, options);\n}\n\nexport class ActivePipelineRunObservers {\n  readonly trace: PipelineTraceInfo | undefined;\n\n  constructor(\n    private readonly observers: readonly ActiveNamedObserver<PipelineRunObservation>[],\n    private readonly options: {\n      readonly primaryTrace?: string | undefined;\n      readonly errorPolicy: PipelineObserverErrorPolicy;\n    },\n  ) {\n    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);\n  }\n\n  async startStage(args: PipelineStageStartArgs): Promise<ActivePipelineStageObservers> {\n    const stageObservers: ActiveNamedObserver<PipelineStageObservation>[] = [];\n    const failures: PipelineObserverFailure[] = [];\n    for (const entry of this.observers) {\n      if (entry.observer.startStage === undefined) continue;\n      try {\n        const observer = await entry.observer.startStage(observerSnapshot(args));\n        if (observer !== undefined) {\n          stageObservers.push({ name: entry.name, observer, terminal: false });\n        }\n      } catch (error) {\n        failures.push({ observer: entry.name, error });\n      }\n    }\n    if (this.options.errorPolicy === \"throw\" && failures.length > 0) {\n      const startupError = new PipelineObserverDispatchError(\"startStage\", failures);\n      const cleanupFailures = await terminateObservers(stageObservers, (observer) =>\n        observer.error?.(observerSnapshot({ ...args, error: startupError, durationMs: 0 })),\n      );\n      throw new PipelineObserverDispatchError(\"startStage\", [...failures, ...cleanupFailures]);\n    }\n    return new ActivePipelineStageObservers(stageObservers, this.options);\n  }\n\n  async end(args: PipelineRunEndArgs): Promise<void> {\n    await dispatchTerminalObservers(\n      this.observers,\n      \"end\",\n      (observer) => observer.end(observerSnapshot(args)),\n      this.options.errorPolicy,\n    );\n  }\n\n  async error(args: PipelineRunErrorArgs): Promise<void> {\n    await dispatchTerminalObservers(\n      this.observers,\n      \"error\",\n      (observer) => observer.error?.(observerSnapshot(args)),\n      \"ignore\",\n    );\n  }\n}\n\nexport class ActivePipelineStageObservers {\n  readonly trace: PipelineTraceInfo | undefined;\n\n  constructor(\n    private readonly observers: readonly ActiveNamedObserver<PipelineStageObservation>[],\n    private readonly options: {\n      readonly primaryTrace?: string | undefined;\n      readonly errorPolicy: PipelineObserverErrorPolicy;\n    },\n  ) {\n    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);\n  }\n\n  async end(args: PipelineStageEndArgs): Promise<void> {\n    await dispatchTerminalObservers(\n      this.observers,\n      \"stage.end\",\n      (observer) => observer.end(observerSnapshot(args)),\n      this.options.errorPolicy,\n    );\n  }\n\n  async error(args: PipelineStageErrorArgs): Promise<void> {\n    await dispatchTerminalObservers(\n      this.observers,\n      \"stage.error\",\n      (observer) => observer.error?.(observerSnapshot(args)),\n      \"ignore\",\n    );\n  }\n}\n\nasync function dispatchTerminalObservers<T>(\n  observers: readonly ActiveNamedObserver<T>[],\n  phase: string,\n  dispatch: (observer: T) => void | Promise<void> | undefined,\n  errorPolicy: PipelineObserverErrorPolicy,\n): Promise<void> {\n  const failures = await terminateObservers(observers, dispatch);\n  if (errorPolicy === \"throw\" && failures.length > 0) {\n    throw new PipelineObserverDispatchError(phase, failures);\n  }\n}\n\nasync function terminateObservers<T>(\n  observers: readonly ActiveNamedObserver<T>[],\n  dispatch: (observer: T) => void | Promise<void> | undefined,\n): Promise<PipelineObserverFailure[]> {\n  const failures: PipelineObserverFailure[] = [];\n  for (const entry of observers) {\n    if (entry.terminal) continue;\n    entry.terminal = true;\n    try {\n      await dispatch(entry.observer);\n    } catch (error) {\n      failures.push({ observer: entry.name, error });\n    }\n  }\n  return failures;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-EZR5AV3J.js

@@ -0,0 +1,74 @@
+// src/internal/async-queue.ts
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let error;
+  function flush() {
+    while (waiters.length > 0 && values.length > 0) {
+      const waiter = waiters.shift();
+      const value = values.shift();
+      if (waiter !== void 0) {
+        waiter.resolve({ value, done: false });
+      }
+    }
+    if (values.length > 0 || waiters.length === 0 || !closed) {
+      return;
+    }
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      if (waiter === void 0) {
+        continue;
+      }
+      if (error !== void 0) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve({ value: void 0, done: true });
+      }
+    }
+  }
+  return {
+    enqueue(value) {
+      if (closed) {
+        return;
+      }
+      values.push(value);
+      flush();
+    },
+    close(options) {
+      if (options?.discardPending) values.length = 0;
+      closed = true;
+      flush();
+    },
+    throw(thrown, options) {
+      if (options?.discardPending) values.length = 0;
+      closed = true;
+      error = thrown;
+      flush();
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (values.length > 0) {
+            const value = values.shift();
+            return Promise.resolve({ value, done: false });
+          }
+          if (error !== void 0) {
+            return Promise.reject(error);
+          }
+          if (closed) {
+            return Promise.resolve({ value: void 0, done: true });
+          }
+          return new Promise((resolve, reject) => {
+            waiters.push({ resolve, reject });
+          });
+        }
+      };
+    }
+  };
+}
+
+export {
+  createAsyncQueue
+};
+//# sourceMappingURL=chunk-EZR5AV3J.js.map

package/dist/chunk-EZR5AV3J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/async-queue.ts"],"sourcesContent":["type AsyncQueueWaiter<T> = {\n  resolve: (result: IteratorResult<T>) => void;\n  reject: (error: unknown) => void;\n};\n\ntype QueueCloseOptions = { discardPending?: boolean };\n\nexport type AsyncQueue<T> = AsyncIterable<T> & {\n  enqueue(value: T): void;\n  close(options?: QueueCloseOptions): void;\n  throw(error: unknown, options?: QueueCloseOptions): void;\n};\n\nexport function createAsyncQueue<T>(): AsyncQueue<T> {\n  const values: T[] = [];\n  const waiters: AsyncQueueWaiter<T>[] = [];\n  let closed = false;\n  let error: unknown;\n\n  function flush(): void {\n    while (waiters.length > 0 && values.length > 0) {\n      const waiter = waiters.shift();\n      const value = values.shift() as T;\n      if (waiter !== undefined) {\n        waiter.resolve({ value, done: false });\n      }\n    }\n\n    if (values.length > 0 || waiters.length === 0 || !closed) {\n      return;\n    }\n\n    while (waiters.length > 0) {\n      const waiter = waiters.shift();\n      if (waiter === undefined) {\n        continue;\n      }\n      if (error !== undefined) {\n        waiter.reject(error);\n      } else {\n        waiter.resolve({ value: undefined, done: true });\n      }\n    }\n  }\n\n  return {\n    enqueue(value: T): void {\n      if (closed) {\n        return;\n      }\n      values.push(value);\n      flush();\n    },\n    close(options?: QueueCloseOptions): void {\n      if (options?.discardPending) values.length = 0;\n      closed = true;\n      flush();\n    },\n    throw(thrown: unknown, options?: QueueCloseOptions): void {\n      if (options?.discardPending) values.length = 0;\n      closed = true;\n      error = thrown;\n      flush();\n    },\n    [Symbol.asyncIterator](): AsyncIterator<T> {\n      return {\n        next(): Promise<IteratorResult<T>> {\n          if (values.length > 0) {\n            const value = values.shift() as T;\n            return Promise.resolve({ value, done: false });\n          }\n          if (error !== undefined) {\n            return Promise.reject(error);\n          }\n          if (closed) {\n            return Promise.resolve({ value: undefined, done: true });\n          }\n          return new Promise((resolve, reject) => {\n            waiters.push({ resolve, reject });\n          });\n        },\n      };\n    },\n  };\n}\n"],"mappings":";AAaO,SAAS,mBAAqC;AACnD,QAAM,SAAc,CAAC;AACrB,QAAM,UAAiC,CAAC;AACxC,MAAI,SAAS;AACb,MAAI;AAEJ,WAAS,QAAc;AACrB,WAAO,QAAQ,SAAS,KAAK,OAAO,SAAS,GAAG;AAC9C,YAAM,SAAS,QAAQ,MAAM;AAC7B,YAAM,QAAQ,OAAO,MAAM;AAC3B,UAAI,WAAW,QAAW;AACxB,eAAO,QAAQ,EAAE,OAAO,MAAM,MAAM,CAAC;AAAA,MACvC;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,KAAK,QAAQ,WAAW,KAAK,CAAC,QAAQ;AACxD;AAAA,IACF;AAEA,WAAO,QAAQ,SAAS,GAAG;AACzB,YAAM,SAAS,QAAQ,MAAM;AAC7B,UAAI,WAAW,QAAW;AACxB;AAAA,MACF;AACA,UAAI,UAAU,QAAW;AACvB,eAAO,OAAO,KAAK;AAAA,MACrB,OAAO;AACL,eAAO,QAAQ,EAAE,OAAO,QAAW,MAAM,KAAK,CAAC;AAAA,MACjD;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,QAAQ,OAAgB;AACtB,UAAI,QAAQ;AACV;AAAA,MACF;AACA,aAAO,KAAK,KAAK;AACjB,YAAM;AAAA,IACR;AAAA,IACA,MAAM,SAAmC;AACvC,UAAI,SAAS,eAAgB,QAAO,SAAS;AAC7C,eAAS;AACT,YAAM;AAAA,IACR;AAAA,IACA,MAAM,QAAiB,SAAmC;AACxD,UAAI,SAAS,eAAgB,QAAO,SAAS;AAC7C,eAAS;AACT,cAAQ;AACR,YAAM;AAAA,IACR;AAAA,IACA,CAAC,OAAO,aAAa,IAAsB;AACzC,aAAO;AAAA,QACL,OAAmC;AACjC,cAAI,OAAO,SAAS,GAAG;AACrB,kBAAM,QAAQ,OAAO,MAAM;AAC3B,mBAAO,QAAQ,QAAQ,EAAE,OAAO,MAAM,MAAM,CAAC;AAAA,UAC/C;AACA,cAAI,UAAU,QAAW;AACvB,mBAAO,QAAQ,OAAO,KAAK;AAAA,UAC7B;AACA,cAAI,QAAQ;AACV,mBAAO,QAAQ,QAAQ,EAAE,OAAO,QAAW,MAAM,KAAK,CAAC;AAAA,UACzD;AACA,iBAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,oBAAQ,KAAK,EAAE,SAAS,OAAO,CAAC;AAAA,UAClC,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-F2OKLHGB.js

@@ -0,0 +1,9 @@
+// src/evals/metric.ts
+function defineMetric(metric) {
+  return metric;
+}
+
+export {
+  defineMetric
+};
+//# sourceMappingURL=chunk-F2OKLHGB.js.map

package/dist/chunk-F2OKLHGB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/evals/metric.ts"],"sourcesContent":["import type { EvalMetric } from \"./types\";\n\nexport function defineMetric<Input, Output, Score, Expected, const Name extends string = string>(\n  metric: EvalMetric<Input, Output, Score, Expected, Name>,\n): EvalMetric<Input, Output, Score, Expected, Name> {\n  return metric;\n}\n"],"mappings":";AAEO,SAAS,aACd,QACkD;AAClD,SAAO;AACT;","names":[]}

package/dist/chunk-F3E2RLC7.js

@@ -0,0 +1,342 @@
+import {
+  createMemoryCompactionSummary,
+  cumulativeCompactedMessageCount
+} from "./chunk-HP34GRQX.js";
+import {
+  MemoryCompactionConflictError,
+  MemoryCompactionError
+} from "./chunk-LQJ4KHMY.js";
+import {
+  Usage
+} from "./chunk-IDNL6IH4.js";
+import {
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
+
+// src/internal/agent-runtime/memory.ts
+var AgentRunMemory = class {
+  constructor(agent, memoryScope, initialHistory) {
+    this.agent = agent;
+    this.memoryScope = memoryScope;
+    this.initialHistory = initialHistory;
+  }
+  agent;
+  memoryScope;
+  initialHistory;
+  memoryPolicy() {
+    return this.memory()?.savePolicy;
+  }
+  pendingTurnMessages(newMessages) {
+    return this.memoryPolicy() === "turn" ? [...newMessages] : [];
+  }
+  async prepareHistory(runId, incomingMessages, abortSignal) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0) {
+      return {
+        history: this.initialHistory,
+        usage: Usage.empty()
+      };
+    }
+    const preparation = await this.prepareStoredHistory(
+      memory,
+      runId,
+      incomingMessages,
+      abortSignal
+    );
+    const memoryHistory = preparation.history;
+    const chatHistory = [...memoryHistory, ...this.initialHistory];
+    return {
+      ...preparation,
+      history: chatHistory
+    };
+  }
+  async compact(runId, abortSignal) {
+    const memory = this.memory();
+    const scope = this.memoryScope;
+    if (memory === void 0 || scope === void 0) {
+      throw new TypeError("Manual memory compaction requires an Agent with configured memory.");
+    }
+    if (memory.compaction === void 0 || memory.store.compaction === void 0) {
+      throw new TypeError("Manual memory compaction requires a configured compaction policy.");
+    }
+    const preparation = await this.prepareStoredHistory(memory, runId, [], abortSignal, true);
+    if (preparation.compaction !== void 0) {
+      return { type: "compacted", ...preparation.compaction };
+    }
+    return {
+      type: "skipped",
+      reason: "nothing_to_compact",
+      originalMessageCount: preparation.history.length,
+      originalTokenCount: preparation.originalTokenCount ?? await countTokens(memory.compaction.tokenCounter, preparation.history)
+    };
+  }
+  async commitAcceptedInput(runId, messages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "message" || messages.length === 0) {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      runId,
+      turn: 1,
+      messages
+    });
+  }
+  async commitMessages(runId, turn, messages, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || messages.length === 0) {
+      return;
+    }
+    if (memory.savePolicy === "message") {
+      await memory.store.append({
+        scope: this.memoryScope,
+        runId,
+        turn,
+        messages
+      });
+    } else if (memory.savePolicy === "turn") {
+      pendingTurnMessages.push(...messages);
+    }
+  }
+  async commitCompletedTurn(runId, turn, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      runId,
+      turn,
+      messages: [...pendingTurnMessages]
+    });
+    pendingTurnMessages.length = 0;
+  }
+  async commitCompletedRun(runId, turn, newMessages, pendingTurnMessages) {
+    await this.commitCompletedTurn(runId, turn, pendingTurnMessages);
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0 || memory.savePolicy !== "run") {
+      return;
+    }
+    await memory.store.append({
+      scope: this.memoryScope,
+      runId,
+      turn,
+      messages: [...newMessages]
+    });
+  }
+  async recordError(runId, error, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryScope === void 0) {
+      return;
+    }
+    await memory.store.recordError?.({
+      scope: this.memoryScope,
+      runId,
+      error,
+      messages: [...newMessages]
+    });
+  }
+  memory() {
+    return this.memoryScope === void 0 ? void 0 : this.agent.memory;
+  }
+  async prepareStoredHistory(memory, runId, incomingMessages, abortSignal, force = false) {
+    const scope = this.memoryScope;
+    if (scope === void 0) {
+      return { history: [], usage: Usage.empty() };
+    }
+    const options = memory.compaction;
+    const capability = memory.store.compaction;
+    if (options === void 0 || capability === void 0) {
+      return {
+        history: await memory.store.load({ scope }),
+        usage: Usage.empty()
+      };
+    }
+    let usage = Usage.empty();
+    const maxAttempts = options.conflictRetries === false ? 1 : options.conflictRetries.maxAttempts;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      throwIfAborted(abortSignal);
+      const snapshot = await capability.snapshot({ scope });
+      throwIfAborted(abortSignal);
+      const selection = await selectCompactionPrefix(
+        snapshot.messages,
+        incomingMessages,
+        options.trigger.afterTokens,
+        options.retention.recentTokens,
+        options.tokenCounter,
+        force
+      );
+      throwIfAborted(abortSignal);
+      const compactedMessageCount = selection.compactedMessageCount;
+      if (compactedMessageCount === 0) {
+        return {
+          history: snapshot.messages,
+          usage,
+          originalTokenCount: selection.originalTokenCount
+        };
+      }
+      const prefix = snapshot.messages.slice(0, compactedMessageCount);
+      let result;
+      try {
+        result = await options.compactor({
+          scope,
+          messages: prefix,
+          abortSignal
+        });
+      } catch (error) {
+        throw remappedCompactorError(error, usage);
+      }
+      if (result.usage !== void 0) {
+        usage = Usage.add(usage, result.usage);
+      }
+      if (typeof result?.summary !== "string") {
+        throw new MemoryCompactionError("Memory compactor must return a summary string.", {
+          usage
+        });
+      }
+      const summaryText = result.summary.trim();
+      if (summaryText.length === 0) {
+        throw new MemoryCompactionError("Memory compactor returned an empty summary.", {
+          usage
+        });
+      }
+      const summary = createMemoryCompactionSummary(
+        summaryText,
+        cumulativeCompactedMessageCount(prefix)
+      );
+      const retained = snapshot.messages.slice(compactedMessageCount);
+      let resultTokenCount;
+      try {
+        resultTokenCount = await countTokens(options.tokenCounter, [summary, ...retained]);
+      } catch (error) {
+        throw remappedCompactorError(error, usage);
+      }
+      throwIfAborted(abortSignal);
+      let replacement;
+      try {
+        replacement = await capability.replacePrefix({
+          scope,
+          revision: snapshot.revision,
+          messageCount: compactedMessageCount,
+          replacement: summary,
+          runId: `memory-compaction:${runId}:${attempt}`
+        });
+      } catch (error) {
+        throw new MemoryCompactionError("Memory compaction prefix replacement failed.", {
+          cause: error,
+          usage
+        });
+      }
+      if (replacement.status === "committed") {
+        return {
+          history: [summary, ...retained],
+          usage,
+          compaction: {
+            originalMessageCount: snapshot.messages.length,
+            compactedMessageCount,
+            retainedMessageCount: retained.length,
+            originalTokenCount: selection.originalTokenCount,
+            compactedTokenCount: selection.compactedTokenCount,
+            retainedTokenCount: selection.retainedTokenCount,
+            resultTokenCount,
+            attempts: attempt,
+            usage
+          }
+        };
+      }
+      throwIfAborted(abortSignal);
+    }
+    throw new MemoryCompactionConflictError(maxAttempts, usage);
+  }
+};
+async function selectCompactionPrefix(messages, incomingMessages, afterTokens, recentTokens, tokenCounter, force) {
+  const originalTokenCount = await countTokens(tokenCounter, messages);
+  const incomingTokenCount = incomingMessages.length === 0 ? 0 : await countTokens(tokenCounter, incomingMessages);
+  const none = {
+    compactedMessageCount: 0,
+    originalTokenCount,
+    compactedTokenCount: 0,
+    retainedTokenCount: originalTokenCount
+  };
+  if (!force && originalTokenCount + incomingTokenCount <= afterTokens) {
+    return none;
+  }
+  const userMessageIndexes = messages.flatMap(
+    (message, index) => message.role === "user" ? [index] : []
+  );
+  if (userMessageIndexes.length <= 1) {
+    return none;
+  }
+  const tailTokenCounts = /* @__PURE__ */ new Map();
+  const countTail = async (messageIndex) => {
+    const cached = tailTokenCounts.get(messageIndex);
+    if (cached !== void 0) return cached;
+    const count = await countTokens(tokenCounter, messages.slice(messageIndex));
+    tailTokenCounts.set(messageIndex, count);
+    return count;
+  };
+  let lower = 0;
+  let upper = userMessageIndexes.length - 1;
+  let retainedBoundary = upper;
+  while (lower <= upper) {
+    const middle = Math.floor((lower + upper) / 2);
+    const candidate = userMessageIndexes[middle] ?? 0;
+    if (await countTail(candidate) <= recentTokens) {
+      retainedBoundary = middle;
+      upper = middle - 1;
+    } else {
+      lower = middle + 1;
+    }
+  }
+  const compactedMessageCount = userMessageIndexes[retainedBoundary] ?? 0;
+  if (compactedMessageCount === 0) {
+    return none;
+  }
+  const compactedTokenCount = await countTokens(
+    tokenCounter,
+    messages.slice(0, compactedMessageCount)
+  );
+  const retainedTokenCount = tailTokenCounts.get(compactedMessageCount) ?? await countTokens(tokenCounter, messages.slice(compactedMessageCount));
+  return {
+    compactedMessageCount,
+    originalTokenCount,
+    compactedTokenCount,
+    retainedTokenCount
+  };
+}
+async function countTokens(tokenCounter, messages) {
+  let count;
+  try {
+    count = await tokenCounter(messages);
+  } catch (error) {
+    throw new MemoryCompactionError("Memory token counter failed.", { cause: error });
+  }
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new MemoryCompactionError("Memory token counter must return a nonnegative safe integer.");
+  }
+  return count;
+}
+function remappedCompactorError(error, usage) {
+  if (error instanceof MemoryCompactionError) {
+    const mergedUsage = error.usage === void 0 ? usage : isEmptyUsage(usage) ? error.usage : Usage.add(usage, error.usage);
+    if (mergedUsage === error.usage || error.usage === void 0 && isEmptyUsage(usage)) {
+      return error;
+    }
+    return new MemoryCompactionError(error.message, {
+      cause: error,
+      usage: mergedUsage
+    });
+  }
+  return new MemoryCompactionError("Memory compactor failed.", {
+    cause: error,
+    usage
+  });
+}
+function isEmptyUsage(usage) {
+  return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
+}
+
+export {
+  AgentRunMemory
+};
+//# sourceMappingURL=chunk-F3E2RLC7.js.map