@anvia/core 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Indra Zulfi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -47,6 +47,69 @@ const response = await agent.prompt("What is happening with order A123?").send()
 console.log(response.output);
 ```
 
+## Prompts and Memory
+
+Use a plain prompt for stateless calls:
+
+```ts
+await agent.prompt("Summarize this ticket.").send();
+```
+
+Use a message array when you already own the transcript. The last message is the active prompt and earlier messages are request history:
+
+```ts
+import { Message } from "@anvia/core";
+
+await agent
+  .prompt([
+    Message.user("My project is named Anvia."),
+    Message.assistant("Noted."),
+    Message.user("What is my project named?"),
+  ])
+  .send();
+```
+
+Configure durable conversation memory on the agent, then run through a session:
+
+```ts
+import {
+  AgentBuilder,
+  type MemoryAppendInput,
+  type MemoryContext,
+  type MemoryStore,
+  type Message,
+} from "@anvia/core";
+
+class AppMemoryStore implements MemoryStore {
+  private readonly sessions = new Map<string, Message[]>();
+
+  async load(context: MemoryContext): Promise<Message[]> {
+    return [...(this.sessions.get(context.sessionId) ?? [])];
+  }
+
+  async append(input: MemoryAppendInput): Promise<void> {
+    const current = this.sessions.get(input.context.sessionId) ?? [];
+    this.sessions.set(input.context.sessionId, [...current, ...input.messages]);
+  }
+
+  async clear(context: MemoryContext): Promise<void> {
+    this.sessions.delete(context.sessionId);
+  }
+}
+
+const memory = new AppMemoryStore();
+const agent = new AgentBuilder("support", model).memory(memory).build();
+
+await agent.session("thread_123", { userId: "user_456" }).prompt("Remember my plan.").send();
+await agent.session("thread_123", { userId: "user_456" }).prompt("What is my plan?").send();
+```
+
+Memory defaults to `savePolicy: "message"`, which saves the user prompt, each completed assistant message, and each completed tool result as soon as they are ready. You can choose `"turn"` or `"run"` at configuration time:
+
+```ts
+new AgentBuilder("support", model).memory(memory, { savePolicy: "turn" });
+```
+
 ## Structured Extraction
 
 ```ts
@@ -80,6 +143,7 @@ const result = await pipeline.run("Customer cannot complete checkout.");
 - `agent`: agent runtime and `AgentBuilder`
 - `tool`: typed tool creation and tool sets
 - `completion`: provider-neutral completion request and response types
+- `memory`: durable session memory interfaces and in-memory store
 - `extractor`: schema-first structured extraction
 - `pipeline`: typed sequential and parallel workflows
 - `embeddings`: embedding helpers and document embedding utilities

package/dist/agent/index.d.ts

@@ -1,5 +1,7 @@
-import { e as DynamicContextOptions, g as DynamicToolOptions, P as PromptHook, A as Agent } from '../agent-C6h6YrRU.js';
-export { a as AgentOptions, b as AgentStreamEvent, c as AgentToolOptions, C as CompletionCallHookArgs, d as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, f as DynamicContextRegistration, h as DynamicToolRegistration, H as HookAction, i as HookResult, j as PromptRequest, k as PromptResponse, R as RunControl, T as ToolCallControl, l as ToolCallHookAction, m as ToolCallHookArgs, n as ToolCallHookResult, o as ToolHookArgs, p as ToolResultHookArgs, q as cancelPrompt, r as createHook, s as runControl, t as skipTool, u as toolCallControl } from '../agent-C6h6YrRU.js';
+import { MemoryStore, MemoryOptions } from '../memory/index.js';
+export { MemoryAppendInput, MemoryContext, MemoryErrorInput, MemoryRegistration, MemorySavePolicy, ResolvedMemoryOptions, SessionOptions, resolveMemoryOptions } from '../memory/index.js';
+import { f as DynamicContextOptions, h as DynamicToolOptions, P as PromptHook, A as Agent } from '../agent-Bj0UqYMp.js';
+export { a as AgentOptions, b as AgentSession, c as AgentStreamEvent, d as AgentToolOptions, C as CompletionCallHookArgs, e as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, g as DynamicContextRegistration, i as DynamicToolRegistration, H as HookAction, j as HookResult, k as PromptRequest, l as PromptResponse, R as RunControl, T as ToolCallControl, m as ToolCallHookAction, n as ToolCallHookArgs, o as ToolCallHookResult, p as ToolHookArgs, q as ToolResultHookArgs, r as cancelPrompt, s as createHook, t as runControl, u as skipTool, v as toolCallControl } from '../agent-Bj0UqYMp.js';
 import { b as CompletionModel, j as JsonValue, o as ToolChoice, M as Message } from '../types-BrxLd7ay.js';
 import { c as McpServer } from '../types-B5B8Sdl4.js';
 import { AgentObserver, ObserveOptions } from '../observability/index.js';
@@ -30,6 +32,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     private observerRegistrations;
     private dynamicContextRegistrations;
     private dynamicToolRegistrations;
+    private memoryRegistration;
     private activeToolSet;
     constructor(agentId: string, completionModel: M);
     name(name: string): this;
@@ -50,6 +53,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     defaultMaxTurns(defaultMaxTurns: number): this;
     hook(hook: PromptHook): this;
     observe(observer: AgentObserver, options?: ObserveOptions): this;
+    memory(store: MemoryStore, options?: MemoryOptions): this;
     outputSchema(schema: ZodSchema): this;
     build(): Agent<M>;
     private buildInstructions;
@@ -67,4 +71,4 @@ declare class PromptCancelledError extends Error {
     constructor(chatHistory: Message[], reason: string);
 }
 
-export { Agent, AgentBuilder, DynamicContextOptions, DynamicToolOptions, MaxTurnsError, PromptCancelledError, PromptHook };
+export { Agent, AgentBuilder, DynamicContextOptions, DynamicToolOptions, MaxTurnsError, MemoryOptions, MemoryStore, PromptCancelledError, PromptHook };

package/dist/agent/index.js

@@ -1,6 +1,7 @@
 import {
   Agent,
   AgentBuilder,
+  AgentSession,
   DEFAULT_MAX_TURNS,
   MaxTurnsError,
   PromptCancelledError,
@@ -10,7 +11,10 @@ import {
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-IQBY2GCF.js";
+} from "../chunk-JQCRURY2.js";
+import {
+  resolveMemoryOptions
+} from "../chunk-XXT2UCAR.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-GNWMOSNR.js";
 import "../chunk-B4QHQN5K.js";
@@ -18,12 +22,14 @@ import "../chunk-CP47FBJV.js";
 export {
   Agent,
   AgentBuilder,
+  AgentSession,
   DEFAULT_MAX_TURNS,
   MaxTurnsError,
   PromptCancelledError,
   PromptRequest,
   cancelPrompt,
   createHook,
+  resolveMemoryOptions,
   runControl,
   skipTool,
   toolCallControl

package/dist/{agent-C6h6YrRU.d.ts → agent-Bj0UqYMp.d.ts}

@@ -1,4 +1,5 @@
 import { M as Message, e as CompletionResponse, b as CompletionModel, U as Usage, l as ReasoningContentType, n as ToolCall, D as Document, j as JsonValue, o as ToolChoice, J as JsonObject } from './types-BrxLd7ay.js';
+import { MemoryContext, MemoryRegistration, SessionOptions } from './memory/index.js';
 import { AgentTraceOptions, AgentTraceInfo, AgentObserverRegistration } from './observability/index.js';
 import { a as ToolSet, T as ToolSearchDocument } from './zod-schema-DJTEgQBq.js';
 import { T as Tool, A as AnyTool } from './tool-DhuBQ3yb.js';
@@ -118,14 +119,17 @@ type AgentStreamEvent<RawResponse = unknown> = {
 declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private readonly agent;
     private readonly promptMessage;
+    private readonly initialHistory;
+    private readonly memoryContext;
     private chatHistory;
     private maxTurnCount;
     private activeHook;
     private concurrency;
     private traceOptions;
     private constructor();
-    static fromAgent<M extends CompletionModel>(agent: Agent<M>, prompt: string | Message): PromptRequest<M>;
-    withHistory(history: Message[]): this;
+    static fromAgent<M extends CompletionModel>(agent: Agent<M>, prompt: string | Message | Message[], options?: {
+        memoryContext?: MemoryContext | undefined;
+    }): PromptRequest<M>;
     maxTurns(maxTurns: number): this;
     requestHook(hook: PromptHook): this;
     withToolConcurrency(concurrency: number): this;
@@ -142,6 +146,13 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private runCompletionCallHook;
     private runCompletionResponseHook;
     private cancelled;
+    private memory;
+    private memoryPolicy;
+    private prepareMemoryRun;
+    private commitMemoryMessages;
+    private commitCompletedMemoryTurn;
+    private commitCompletedMemoryRun;
+    private recordMemoryError;
 }
 
 type AgentOptions<M extends CompletionModel = CompletionModel> = {
@@ -162,6 +173,7 @@ type AgentOptions<M extends CompletionModel = CompletionModel> = {
     observers?: AgentObserverRegistration[] | undefined;
     dynamicContexts?: DynamicContextRegistration[] | undefined;
     dynamicTools?: DynamicToolRegistration[] | undefined;
+    memory?: MemoryRegistration | undefined;
 };
 declare const DEFAULT_MAX_TURNS = 20;
 type AgentToolOptions = {
@@ -206,13 +218,27 @@ declare class Agent<M extends CompletionModel = CompletionModel> {
     readonly observers: AgentObserverRegistration[];
     readonly dynamicContexts: DynamicContextRegistration[];
     readonly dynamicTools: DynamicToolRegistration[];
+    readonly memory: MemoryRegistration | undefined;
     constructor(options: AgentOptions<M>);
-    prompt(prompt: string | Message): PromptRequest<M>;
+    prompt(prompt: string | Message | Message[]): PromptRequest<M>;
+    session(sessionId: string, options?: SessionOptions): AgentSession<M>;
     asTool(options: AgentToolOptions): Tool<{
         prompt: string;
     }, string>;
     getTool(toolName: string): AnyTool | undefined;
     callTool(toolName: string, args: string): Promise<string>;
 }
+declare class AgentSession<M extends CompletionModel = CompletionModel> {
+    private readonly agent;
+    private readonly context;
+    constructor(agent: Agent<M>, context: {
+        sessionId: string;
+        userId?: string | undefined;
+        metadata?: JsonObject | undefined;
+    });
+    prompt(prompt: string | Message): PromptRequest<M>;
+    messages(): Promise<Message[]>;
+    clear(): Promise<void>;
+}
 
-export { Agent as A, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, type HookAction as H, type PromptHook as P, type RunControl as R, type ToolCallControl as T, type AgentOptions as a, type AgentStreamEvent as b, type AgentToolOptions as c, type CompletionResponseHookArgs as d, type DynamicContextOptions as e, type DynamicContextRegistration as f, type DynamicToolOptions as g, type DynamicToolRegistration as h, type HookResult as i, PromptRequest as j, type PromptResponse as k, type ToolCallHookAction as l, type ToolCallHookArgs as m, type ToolCallHookResult as n, type ToolHookArgs as o, type ToolResultHookArgs as p, cancelPrompt as q, createHook as r, runControl as s, skipTool as t, toolCallControl as u };
+export { Agent as A, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, type HookAction as H, type PromptHook as P, type RunControl as R, type ToolCallControl as T, type AgentOptions as a, AgentSession as b, type AgentStreamEvent as c, type AgentToolOptions as d, type CompletionResponseHookArgs as e, type DynamicContextOptions as f, type DynamicContextRegistration as g, type DynamicToolOptions as h, type DynamicToolRegistration as i, type HookResult as j, PromptRequest as k, type PromptResponse as l, type ToolCallHookAction as m, type ToolCallHookArgs as n, type ToolCallHookResult as o, type ToolHookArgs as p, type ToolResultHookArgs as q, cancelPrompt as r, createHook as s, runControl as t, skipTool as u, toolCallControl as v };

package/dist/{chunk-LMBOJMNB.js → chunk-C7XTEV5W.js}

@@ -1,6 +1,6 @@
 import {
   ExtractorBuilder
-} from "./chunk-IA76K5UX.js";
+} from "./chunk-O3TUS5RB.js";
 import {
   cosineSimilarity,
   embedText
@@ -301,4 +301,4 @@ export {
   llmScore,
   agentEvalTarget
 };
-//# sourceMappingURL=chunk-LMBOJMNB.js.map
+//# sourceMappingURL=chunk-C7XTEV5W.js.map

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

@@ -1,3 +1,6 @@
+import {
+  resolveMemoryOptions
+} from "./chunk-XXT2UCAR.js";
 import {
   toReadableStream
 } from "./chunk-XUUY2L2D.js";
@@ -453,25 +456,27 @@ 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;
+  static fromAgent(agent, prompt, options = {}) {
+    const normalized = normalizePromptInput(prompt);
+    return new _PromptRequest(agent, normalized.prompt, normalized.history, options.memoryContext);
   }
   maxTurns(maxTurns) {
     this.maxTurnCount = maxTurns;
@@ -490,7 +495,10 @@ var PromptRequest = class _PromptRequest {
     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 +511,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 +520,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 +551,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 +567,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 +583,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 +628,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 +645,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 +681,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;
     }
@@ -760,7 +797,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 +887,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 +1095,7 @@ var Agent = class {
   observers;
   dynamicContexts;
   dynamicTools;
+  memory;
   constructor(options) {
     this.id = normalizeAgentId(options.id);
     this.name = options.name;
@@ -980,10 +1114,25 @@ var Agent = class {
     this.observers = options.observers ?? [];
     this.dynamicContexts = options.dynamicContexts ?? [];
     this.dynamicTools = options.dynamicTools ?? [];
+    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({
@@ -1026,6 +1175,34 @@ var Agent = class {
     return this.toolSet.call(toolName, args);
   }
 };
+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;
   return maybeIndex.toolSet instanceof ToolSet ? maybeIndex.toolSet : void 0;
@@ -1064,6 +1241,7 @@ var AgentBuilder = class {
   observerRegistrations = [];
   dynamicContextRegistrations = [];
   dynamicToolRegistrations = [];
+  memoryRegistration;
   activeToolSet = new ToolSet();
   name(name) {
     this.agentName = name;
@@ -1148,6 +1326,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 +1355,8 @@ var AgentBuilder = class {
       outputSchema: this.schema,
       observers: this.observerRegistrations,
       dynamicContexts: this.dynamicContextRegistrations,
-      dynamicTools: this.dynamicToolRegistrations
+      dynamicTools: this.dynamicToolRegistrations,
+      memory: this.memoryRegistration
     });
   }
   buildInstructions() {
@@ -1202,6 +1388,7 @@ export {
   PromptRequest,
   DEFAULT_MAX_TURNS,
   Agent,
+  AgentSession,
   AgentBuilder
 };
-//# sourceMappingURL=chunk-IQBY2GCF.js.map
+//# sourceMappingURL=chunk-JQCRURY2.js.map