@anvia/core 0.1.0 → 0.1.2

package/dist/{chunk-IQBY2GCF.js → chunk-BIJ5ZBCO.js}

@@ -1,3 +1,9 @@
+import {
+  resolveMemoryOptions
+} from "./chunk-XXT2UCAR.js";
+import {
+  isSkillTool
+} from "./chunk-YK4WAAS4.js";
 import {
   toReadableStream
 } from "./chunk-XUUY2L2D.js";
@@ -453,25 +459,28 @@ function reasoningDeltaEvent(event) {
 
 // src/agent/request.ts
 var PromptRequest = class _PromptRequest {
-  constructor(agent, promptMessage) {
+  constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
     this.agent = agent;
     this.promptMessage = promptMessage;
+    this.initialHistory = initialHistory;
+    this.memoryContext = memoryContext;
+    this.chatHistory = initialHistory;
     this.maxTurnCount = agent.defaultMaxTurns ?? 0;
     this.activeHook = agent.hook;
   }
   agent;
   promptMessage;
+  initialHistory;
+  memoryContext;
   chatHistory;
   maxTurnCount;
   activeHook;
   concurrency = 1;
   traceOptions;
-  static fromAgent(agent, prompt) {
-    return new _PromptRequest(agent, typeof prompt === "string" ? Message.user(prompt) : prompt);
-  }
-  withHistory(history) {
-    this.chatHistory = history;
-    return this;
+  requestToolMiddlewares = [];
+  static fromAgent(agent, prompt, options = {}) {
+    const normalized = normalizePromptInput(prompt);
+    return new _PromptRequest(agent, normalized.prompt, normalized.history, options.memoryContext);
   }
   maxTurns(maxTurns) {
     this.maxTurnCount = maxTurns;
@@ -485,12 +494,23 @@ var PromptRequest = class _PromptRequest {
     this.concurrency = Math.max(1, concurrency);
     return this;
   }
+  withToolMiddleware(middleware) {
+    this.requestToolMiddlewares.push(middleware);
+    return this;
+  }
+  withToolMiddlewares(middlewares) {
+    this.requestToolMiddlewares.push(...middlewares);
+    return this;
+  }
   withTrace(trace) {
     this.traceOptions = trace;
     return this;
   }
   async send() {
+    const runId = globalThis.crypto.randomUUID();
     const newMessages = [this.promptMessage];
+    await this.prepareMemoryRun(runId, newMessages);
+    const pendingTurnMessages = this.memoryPolicy() === "turn" ? [...newMessages] : [];
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
@@ -503,7 +523,7 @@ var PromptRequest = class _PromptRequest {
         }
         lastPrompt = prompt;
         currentTurns += 1;
-        const historyForRequest = [...this.chatHistory ?? [], ...newMessages.slice(0, -1)];
+        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
         const ragText = extractRagText(prompt);
         const dynamicContext = await this.fetchDynamicContext(ragText);
@@ -512,11 +532,24 @@ var PromptRequest = class _PromptRequest {
         const response = await this.runCompletion(request, currentTurns, runObservers);
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
-        newMessages.push(Message.assistant(response.choice, response.messageId));
+        const assistantMessage = Message.assistant(response.choice, response.messageId);
+        newMessages.push(assistantMessage);
+        await this.commitMemoryMessages(
+          runId,
+          currentTurns,
+          [assistantMessage],
+          pendingTurnMessages
+        );
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
         if (toolCalls.length === 0) {
+          await this.commitCompletedMemoryRun(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages
+          );
           const result = {
             output: textFromAssistantContent(response.choice),
             usage,
@@ -530,15 +563,15 @@ var PromptRequest = class _PromptRequest {
           turn: currentTurns,
           runObservers
         });
-        newMessages.push(Message.tool(toolResults));
+        const toolMessage = Message.tool(toolResults);
+        newMessages.push(toolMessage);
+        await this.commitMemoryMessages(runId, currentTurns, [toolMessage], pendingTurnMessages);
+        await this.commitCompletedMemoryTurn(runId, currentTurns, pendingTurnMessages);
       }
-      throw new MaxTurnsError(
-        this.maxTurnCount,
-        [...this.chatHistory ?? [], ...newMessages],
-        lastPrompt
-      );
+      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
       await runObservers.error({ error, usage, messages: [...newMessages] });
+      await this.recordMemoryError(runId, error, newMessages);
       throw error;
     }
   }
@@ -546,7 +579,10 @@ var PromptRequest = class _PromptRequest {
     if (!this.agent.model.capabilities.streaming || !isStreamingCompletionModel(this.agent.model)) {
       throw new Error("This completion model does not support streaming");
     }
+    const runId = globalThis.crypto.randomUUID();
     const newMessages = [this.promptMessage];
+    await this.prepareMemoryRun(runId, newMessages);
+    const pendingTurnMessages = this.memoryPolicy() === "turn" ? [...newMessages] : [];
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
@@ -559,7 +595,7 @@ var PromptRequest = class _PromptRequest {
         }
         lastPrompt = prompt;
         currentTurns += 1;
-        const historyForRequest = [...this.chatHistory ?? [], ...newMessages.slice(0, -1)];
+        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
         yield {
           type: "turn_start",
           turn: currentTurns,
@@ -604,7 +640,14 @@ var PromptRequest = class _PromptRequest {
         });
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
-        newMessages.push(Message.assistant(response.choice, response.messageId));
+        const assistantMessage = Message.assistant(response.choice, response.messageId);
+        newMessages.push(assistantMessage);
+        await this.commitMemoryMessages(
+          runId,
+          currentTurns,
+          [assistantMessage],
+          pendingTurnMessages
+        );
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
@@ -614,6 +657,12 @@ var PromptRequest = class _PromptRequest {
         yield { type: "turn_end", turn: currentTurns, response };
         if (toolCalls.length === 0) {
           const output = textFromAssistantContent(response.choice);
+          await this.commitCompletedMemoryRun(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages
+          );
           yield {
             type: "final",
             output,
@@ -644,15 +693,15 @@ var PromptRequest = class _PromptRequest {
           yield { type: "tool_result", turn: currentTurns, ...result };
         }
         const toolResults = await toolResultsPromise;
-        newMessages.push(Message.tool(toolResults));
+        const toolMessage = Message.tool(toolResults);
+        newMessages.push(toolMessage);
+        await this.commitMemoryMessages(runId, currentTurns, [toolMessage], pendingTurnMessages);
+        await this.commitCompletedMemoryTurn(runId, currentTurns, pendingTurnMessages);
       }
-      throw new MaxTurnsError(
-        this.maxTurnCount,
-        [...this.chatHistory ?? [], ...newMessages],
-        lastPrompt
-      );
+      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
       await runObservers.error({ error, usage, messages: [...newMessages] });
+      await this.recordMemoryError(runId, error, newMessages);
       yield { type: "error", error };
       throw error;
     }
@@ -719,6 +768,14 @@ var PromptRequest = class _PromptRequest {
           output = error instanceof Error ? error.toString() : String(error);
         }
       }
+      if (this.agent.shouldApplyToolMiddleware(toolCall.function.name)) {
+        output = await this.runToolResultMiddlewares({
+          ...hookArgs,
+          result: output,
+          originalResult: output,
+          turn: observation?.turn ?? 0
+        });
+      }
       const resultAction = await this.activeHook?.onToolResult?.({
         ...hookArgs,
         result: output,
@@ -750,6 +807,19 @@ var PromptRequest = class _PromptRequest {
       return ToolContent.toolResult(toolCall.id, output, toolCall.callId);
     });
   }
+  async runToolResultMiddlewares(args) {
+    let result = args.result;
+    for (const middleware of [...this.agent.toolMiddlewares, ...this.requestToolMiddlewares]) {
+      const replacement = await middleware.onResult?.({
+        ...args,
+        result
+      });
+      if (replacement !== void 0) {
+        result = replacement;
+      }
+    }
+    return result;
+  }
   async startRunObservers() {
     const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
     return startAgentRunObservers(
@@ -760,7 +830,7 @@ var PromptRequest = class _PromptRequest {
         instructions: this.agent.instructions,
         trace: this.traceOptions,
         prompt: this.promptMessage,
-        history: this.chatHistory ?? [],
+        history: this.chatHistory,
         maxTurns: this.maxTurnCount
       },
       failOnObserverError
@@ -850,9 +920,105 @@ var PromptRequest = class _PromptRequest {
     }
   }
   cancelled(newMessages, reason) {
-    return new PromptCancelledError([...this.chatHistory ?? [], ...newMessages], reason);
+    return new PromptCancelledError([...this.chatHistory, ...newMessages], reason);
+  }
+  memory() {
+    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
+  }
+  memoryPolicy() {
+    return this.memory()?.options.savePolicy;
+  }
+  async prepareMemoryRun(runId, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0) {
+      this.chatHistory = this.initialHistory;
+      return;
+    }
+    const memoryHistory = await memory.store.load(this.memoryContext);
+    this.chatHistory = [...memoryHistory, ...this.initialHistory];
+    if (memory.options.savePolicy === "message") {
+      await memory.store.append({
+        context: this.memoryContext,
+        runId,
+        turn: 1,
+        messages: newMessages
+      });
+    }
+  }
+  async commitMemoryMessages(runId, turn, messages, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
+      return;
+    }
+    if (memory.options.savePolicy === "message") {
+      await memory.store.append({
+        context: this.memoryContext,
+        runId,
+        turn,
+        messages
+      });
+    } else if (memory.options.savePolicy === "turn") {
+      pendingTurnMessages.push(...messages);
+    }
+  }
+  async commitCompletedMemoryTurn(runId, turn, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
+      return;
+    }
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn,
+      messages: [...pendingTurnMessages]
+    });
+    pendingTurnMessages.length = 0;
+  }
+  async commitCompletedMemoryRun(runId, turn, newMessages, pendingTurnMessages) {
+    await this.commitCompletedMemoryTurn(runId, turn, pendingTurnMessages);
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "run") {
+      return;
+    }
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn,
+      messages: [...newMessages]
+    });
+  }
+  async recordMemoryError(runId, error, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0) {
+      return;
+    }
+    await memory.store.recordError?.({
+      context: this.memoryContext,
+      runId,
+      error,
+      messages: [...newMessages]
+    });
   }
 };
+function normalizePromptInput(prompt) {
+  if (typeof prompt === "string") {
+    return { prompt: Message.user(prompt), history: [] };
+  }
+  if (!Array.isArray(prompt)) {
+    return { prompt, history: [] };
+  }
+  if (prompt.length === 0) {
+    throw new TypeError("Prompt transcript must contain at least one message.");
+  }
+  const activePrompt = prompt.at(-1);
+  if (activePrompt === void 0) {
+    throw new TypeError("Prompt transcript must contain at least one message.");
+  }
+  return {
+    prompt: activePrompt,
+    history: prompt.slice(0, -1)
+  };
+}
 function createAsyncQueue() {
   const values = [];
   const waiters = [];
@@ -962,6 +1128,8 @@ var Agent = class {
   observers;
   dynamicContexts;
   dynamicTools;
+  toolMiddlewares;
+  memory;
   constructor(options) {
     this.id = normalizeAgentId(options.id);
     this.name = options.name;
@@ -980,10 +1148,26 @@ var Agent = class {
     this.observers = options.observers ?? [];
     this.dynamicContexts = options.dynamicContexts ?? [];
     this.dynamicTools = options.dynamicTools ?? [];
+    this.toolMiddlewares = options.toolMiddlewares ?? [];
+    this.memory = options.memory;
   }
   prompt(prompt) {
     return PromptRequest.fromAgent(this, prompt);
   }
+  session(sessionId, options = {}) {
+    if (this.memory === void 0) {
+      throw new Error(`Agent "${this.id}" has no memory store configured.`);
+    }
+    const normalized = sessionId.trim();
+    if (normalized.length === 0) {
+      throw new TypeError("Session id must be a non-empty string.");
+    }
+    return new AgentSession(this, {
+      sessionId: normalized,
+      ...options.userId === void 0 ? {} : { userId: options.userId },
+      ...options.metadata === void 0 ? {} : { metadata: options.metadata }
+    });
+  }
   asTool(options) {
     const description = options.description ?? this.description ?? `Prompt the ${options.name} agent.`;
     return createTool({
@@ -1025,6 +1209,37 @@ var Agent = class {
     }
     return this.toolSet.call(toolName, args);
   }
+  shouldApplyToolMiddleware(toolName) {
+    return !isSkillTool(this.getTool(toolName));
+  }
+};
+var AgentSession = class {
+  constructor(agent, context) {
+    this.agent = agent;
+    this.context = context;
+  }
+  agent;
+  context;
+  prompt(prompt) {
+    if (Array.isArray(prompt)) {
+      throw new TypeError("AgentSession.prompt does not accept Message[] transcripts.");
+    }
+    return PromptRequest.fromAgent(this.agent, prompt, { memoryContext: this.context });
+  }
+  async messages() {
+    const memory = this.agent.memory;
+    if (memory === void 0) {
+      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
+    }
+    return memory.store.load(this.context);
+  }
+  async clear() {
+    const memory = this.agent.memory;
+    if (memory === void 0) {
+      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
+    }
+    await memory.store.clear(this.context);
+  }
 };
 function dynamicToolSetFromIndex(index) {
   const maybeIndex = index;
@@ -1064,6 +1279,8 @@ var AgentBuilder = class {
   observerRegistrations = [];
   dynamicContextRegistrations = [];
   dynamicToolRegistrations = [];
+  middlewareRegistrations = [];
+  memoryRegistration;
   activeToolSet = new ToolSet();
   name(name) {
     this.agentName = name;
@@ -1141,6 +1358,14 @@ var AgentBuilder = class {
     this.requestHook = hook;
     return this;
   }
+  toolMiddleware(middleware) {
+    this.middlewareRegistrations.push(middleware);
+    return this;
+  }
+  toolMiddlewares(middlewares) {
+    this.middlewareRegistrations.push(...middlewares);
+    return this;
+  }
   observe(observer, options = {}) {
     this.observerRegistrations.push({
       observer,
@@ -1148,6 +1373,13 @@ var AgentBuilder = class {
     });
     return this;
   }
+  memory(store, options = {}) {
+    this.memoryRegistration = {
+      store,
+      options: resolveMemoryOptions(options)
+    };
+    return this;
+  }
   outputSchema(schema) {
     this.schema = toProviderJsonSchema(schema);
     return this;
@@ -1170,7 +1402,9 @@ var AgentBuilder = class {
       outputSchema: this.schema,
       observers: this.observerRegistrations,
       dynamicContexts: this.dynamicContextRegistrations,
-      dynamicTools: this.dynamicToolRegistrations
+      dynamicTools: this.dynamicToolRegistrations,
+      toolMiddlewares: this.middlewareRegistrations,
+      memory: this.memoryRegistration
     });
   }
   buildInstructions() {
@@ -1202,6 +1436,7 @@ export {
   PromptRequest,
   DEFAULT_MAX_TURNS,
   Agent,
+  AgentSession,
   AgentBuilder
 };
-//# sourceMappingURL=chunk-IQBY2GCF.js.map
+//# sourceMappingURL=chunk-BIJ5ZBCO.js.map