@anvia/core 0.17.0 → 0.18.0

package/dist/agent/index.d.ts

@@ -1,11 +1,11 @@
-import { D as DynamicContextOptions, b as DynamicToolOptions, c as AgentEventStore, d as AgentEventStoreOptions, A as Agent } from '../agent-Cg0UigNK.js';
-export { e as AgentEventAppendInput, f as AgentEventRecord, g as AgentEventStoreInclude, h as AgentSession, i as AgentToolOptions } from '../agent-Cg0UigNK.js';
+import { D as DynamicContextOptions, b as DynamicToolOptions, c as AgentEventStore, d as AgentEventStoreOptions, A as Agent } from '../agent-CBz3CRxa.js';
+export { e as AgentEventAppendInput, f as AgentEventRecord, g as AgentEventStoreInclude, h as AgentSession, i as AgentToolOptions } from '../agent-CBz3CRxa.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
 import { C as CompletionModel, P as ProviderTool, i as JsonValue, z as ToolChoice } from '../types-XjIh933x.js';
 import { GuardrailPolicyInput } from '../guardrails/index.js';
 import { P as PromptHook } from '../types-BCA8p0sb.js';
 import { a as McpServer } from '../types-BBEf34DP.js';
-import { e as MemoryStore, f as MemoryOptions } from '../types-CBmhLT_r.js';
+import { m as MemoryStore, n as MemoryOptions } from '../types-DBHzPsbx.js';
 import { i as AgentObserver, O as ObserveOptions } from '../index-XTUEMWhU.js';
 import { a as SkillSet } from '../types-fBv8mhvP.js';
 import { k as ToolSearchDocument, l as ToolSet, A as AgentMiddleware, e as ToolMiddleware } from '../middleware-Cp0tm6zE.js';

package/dist/agent/index.js

@@ -1,19 +1,21 @@
 import {
   AgentBuilder
-} from "../chunk-RWAOHGRL.js";
-import "../chunk-BQCTJSNL.js";
-import "../chunk-OPAEENGD.js";
+} from "../chunk-DPTZ2MK4.js";
+import "../chunk-QABIBFKE.js";
+import "../chunk-7LCKIULT.js";
 import "../chunk-YK4WAAS4.js";
 import "../chunk-XUUY2L2D.js";
-import "../chunk-SWUIBS4N.js";
-import "../chunk-F3C5653H.js";
+import "../chunk-JNJBKSLA.js";
+import "../chunk-I7TM7TKX.js";
 import "../chunk-2ODTMRHP.js";
-import "../chunk-M6RPFHG7.js";
-import "../chunk-YBBD4HZ3.js";
-import "../chunk-OIMLU4SF.js";
-import "../chunk-GCED5ZNM.js";
+import "../chunk-ZNTIUOKL.js";
+import "../chunk-TGLNXVII.js";
+import "../chunk-MTGNA4OS.js";
+import "../chunk-F56AMXMQ.js";
 import "../chunk-PJDL5UT2.js";
 import "../chunk-WQKHFADH.js";
+import "../chunk-YBBD4HZ3.js";
+import "../chunk-OIMLU4SF.js";
 import "../chunk-CWUJUSOS.js";
 export {
   AgentBuilder

package/dist/{agent-Cg0UigNK.d.ts → agent-CBz3CRxa.d.ts}

@@ -1,7 +1,7 @@
 import { C as CompletionModel, M as Message, D as Document, i as JsonValue, P as ProviderTool, z as ToolChoice, J as JsonObject } from './types-XjIh933x.js';
 import { GuardrailPolicyInput, GuardrailPolicy } from './guardrails/index.js';
 import { P as PromptHook } from './types-BCA8p0sb.js';
-import { h as MemoryContext, j as MemoryRegistration, S as SessionOptions } from './types-CBmhLT_r.js';
+import { q as MemoryContext, s as MemoryRegistration, u as SessionOptions } from './types-DBHzPsbx.js';
 import { j as AgentTraceOptions, P as PromptResponse, d as AgentStreamEvent, f as AgentStreamEventWithoutToolCallDeltas, g as AgentStreamOptions, k as AgentObserverRegistration } from './index-XTUEMWhU.js';
 import { e as ToolApprovalsOptions, T as Tool, A as AnyTool, f as ToolCallContext, N as NormalizedToolOutput } from './tool-Dhwg__1L.js';
 import { A as AgentMiddleware, e as ToolMiddleware, k as ToolSearchDocument, l as ToolSet } from './middleware-Cp0tm6zE.js';
@@ -83,6 +83,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private executeToolCalls;
     private runOutputGuardrailsForResponse;
     private recordGuardrailDecision;
+    private recordMemoryCompaction;
     private guardrailRunContext;
     private startRunObservers;
     private recordAgentEvent;

package/dist/{chunk-54S4I3SX.js → chunk-3YJXLOGO.js}

@@ -1,15 +1,15 @@
 import {
   AgentBuilder
-} from "./chunk-RWAOHGRL.js";
+} from "./chunk-DPTZ2MK4.js";
 import {
   extractRagText
-} from "./chunk-OPAEENGD.js";
+} from "./chunk-7LCKIULT.js";
 import {
   createTool
-} from "./chunk-F3C5653H.js";
+} from "./chunk-I7TM7TKX.js";
 import {
   CompletionRequestBuilder
-} from "./chunk-GCED5ZNM.js";
+} from "./chunk-MTGNA4OS.js";
 import {
   CompletionCapabilityError,
   Message,
@@ -138,4 +138,4 @@ export {
   Extractor,
   ExtractorBuilder
 };
-//# sourceMappingURL=chunk-54S4I3SX.js.map
+//# sourceMappingURL=chunk-3YJXLOGO.js.map

package/dist/{chunk-OPAEENGD.js → chunk-7LCKIULT.js}

@@ -4,18 +4,23 @@ import {
 import {
   parseToolArgs,
   toolResultContentToText
-} from "./chunk-SWUIBS4N.js";
+} from "./chunk-JNJBKSLA.js";
 import {
   runControl,
   toolCallControl
 } from "./chunk-2ODTMRHP.js";
 import {
-  mapWithConcurrency
-} from "./chunk-OIMLU4SF.js";
+  MemoryCompactionConflictError,
+  MemoryCompactionError,
+  createMemoryCompactionSummary,
+  cumulativeCompactedMessageCount
+} from "./chunk-TGLNXVII.js";
+import {
+  CompletionRequestBuilder
+} from "./chunk-MTGNA4OS.js";
 import {
-  CompletionRequestBuilder,
   isStreamingCompletionModel
-} from "./chunk-GCED5ZNM.js";
+} from "./chunk-F56AMXMQ.js";
 import {
   AssistantContent,
   Message,
@@ -25,6 +30,9 @@ import {
   getAssistantGenerationMetadata,
   textFromAssistantContent
 } from "./chunk-PJDL5UT2.js";
+import {
+  mapWithConcurrency
+} from "./chunk-OIMLU4SF.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
@@ -151,9 +159,13 @@ var PromptRequestMemory = class {
   async prepareRun(runId, newMessages) {
     const memory = this.memory();
     if (memory === void 0 || this.memoryContext === void 0) {
-      return this.initialHistory;
+      return {
+        history: this.initialHistory,
+        usage: Usage.empty()
+      };
     }
-    const memoryHistory = await memory.store.load(this.memoryContext);
+    const preparation = await this.prepareStoredHistory(memory, runId, newMessages.length);
+    const memoryHistory = preparation.history;
     const chatHistory = [...memoryHistory, ...this.initialHistory];
     if (memory.options.savePolicy === "message") {
       await memory.store.append({
@@ -163,7 +175,10 @@ var PromptRequestMemory = class {
         messages: newMessages
       });
     }
-    return chatHistory;
+    return {
+      ...preparation,
+      history: chatHistory
+    };
   }
   async commitMessages(runId, turn, messages, pendingTurnMessages) {
     const memory = this.memory();
@@ -222,7 +237,119 @@ var PromptRequestMemory = class {
   memory() {
     return this.memoryContext === void 0 ? void 0 : this.agent.memory;
   }
+  async prepareStoredHistory(memory, runId, incomingMessageCount) {
+    const context = this.memoryContext;
+    if (context === void 0) {
+      return { history: [], usage: Usage.empty() };
+    }
+    const options = memory.options.compaction;
+    const capability = memory.store.compaction;
+    if (options === void 0 || capability === void 0) {
+      return {
+        history: await memory.store.load(context),
+        usage: Usage.empty()
+      };
+    }
+    let usage = Usage.empty();
+    let conflictRetries = 0;
+    for (let attempt = 0; attempt <= options.conflictRetries; attempt += 1) {
+      const snapshot = await capability.load(context);
+      const compactedMessageCount = compactedPrefixLength(
+        snapshot.messages,
+        incomingMessageCount,
+        options.maxMessages,
+        options.keepRecentUserTurns
+      );
+      if (compactedMessageCount === 0) {
+        return { history: snapshot.messages, usage };
+      }
+      const prefix = snapshot.messages.slice(0, compactedMessageCount);
+      let result;
+      try {
+        result = await options.compactor({
+          context,
+          messages: prefix
+        });
+      } catch (error) {
+        throw remappedCompactorError(error, usage);
+      }
+      if (result.usage !== void 0) {
+        usage = Usage.add(usage, result.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)
+      );
+      let commit;
+      try {
+        commit = await capability.commit({
+          context,
+          revision: snapshot.revision,
+          compactedMessageCount,
+          summary,
+          runId: `memory-compaction:${runId}:${attempt + 1}`
+        });
+      } catch (error) {
+        throw new MemoryCompactionError("Memory compaction store commit failed.", {
+          cause: error,
+          usage
+        });
+      }
+      if (commit === "committed") {
+        const retained = snapshot.messages.slice(compactedMessageCount);
+        return {
+          history: [summary, ...retained],
+          usage,
+          compaction: {
+            originalMessageCount: snapshot.messages.length,
+            compactedMessageCount,
+            retainedMessageCount: retained.length,
+            conflictRetries
+          }
+        };
+      }
+      conflictRetries += 1;
+    }
+    throw new MemoryCompactionConflictError(options.conflictRetries + 1, usage);
+  }
 };
+function compactedPrefixLength(messages, incomingMessageCount, maxMessages, keepRecentUserTurns) {
+  if (messages.length + incomingMessageCount <= maxMessages) {
+    return 0;
+  }
+  const userMessageIndexes = messages.flatMap(
+    (message, index) => message.role === "user" ? [index] : []
+  );
+  if (userMessageIndexes.length <= keepRecentUserTurns) {
+    return 0;
+  }
+  return userMessageIndexes[userMessageIndexes.length - keepRecentUserTurns] ?? 0;
+}
+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;
+}
 
 // src/internal/prompt-runtime/retrieval.ts
 async function fetchDynamicContext(agent, ragText) {
@@ -1628,7 +1755,10 @@ var PromptRequest = class _PromptRequest {
         return result;
       }
       newMessages = [this.promptMessage];
-      this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+      const memoryPreparation = await this.memoryRecorder.prepareRun(runId, newMessages);
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
       const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
@@ -1744,6 +1874,9 @@ var PromptRequest = class _PromptRequest {
       }
       throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
+      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
+        usage = Usage.add(usage, error.usage);
+      }
       const finalError = await this.runRunErrorHook(error, usage, newMessages);
       this.runState = finalError instanceof PromptCancelledError ? "cancelled" : "errored";
       await runObservers.error({ error: finalError, usage, messages: [...newMessages] });
@@ -1801,7 +1934,10 @@ var PromptRequest = class _PromptRequest {
         return;
       }
       newMessages = [this.promptMessage];
-      this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+      const memoryPreparation = await this.memoryRecorder.prepareRun(runId, newMessages);
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
       const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
@@ -2073,6 +2209,9 @@ var PromptRequest = class _PromptRequest {
       }
       throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
+      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
+        usage = Usage.add(usage, error.usage);
+      }
       const finalError = await this.runRunErrorHook(error, usage, newMessages);
       this.runState = finalError instanceof PromptCancelledError ? "cancelled" : "errored";
       const finalUsage = usage;
@@ -2244,6 +2383,24 @@ var PromptRequest = class _PromptRequest {
       attributes: guardrailDecisionAttributes(decision)
     });
   }
+  async recordMemoryCompaction(preparation, runObservers) {
+    const compaction = preparation.compaction;
+    if (compaction === void 0) {
+      return;
+    }
+    await runObservers.event({
+      name: "memory.compaction",
+      attributes: {
+        originalMessageCount: compaction.originalMessageCount,
+        compactedMessageCount: compaction.compactedMessageCount,
+        retainedMessageCount: compaction.retainedMessageCount,
+        conflictRetries: compaction.conflictRetries,
+        inputTokens: preparation.usage.inputTokens,
+        outputTokens: preparation.usage.outputTokens,
+        totalTokens: preparation.usage.totalTokens
+      }
+    });
+  }
   guardrailRunContext(runId) {
     const context = {
       agentId: this.agent.id,
@@ -2593,4 +2750,4 @@ export {
   extractRagText,
   PromptRequest
 };
-//# sourceMappingURL=chunk-OPAEENGD.js.map
+//# sourceMappingURL=chunk-7LCKIULT.js.map