@anvia/core 0.1.0 → 0.1.2

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,9 +1,11 @@
-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-D5KKP9_z.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-D5KKP9_z.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';
-import { T as ToolSearchDocument, a as ToolSet, Z as ZodSchema } from '../zod-schema-DJTEgQBq.js';
+import { b as ToolSearchDocument, c as ToolSet, T as ToolMiddleware, Z as ZodSchema } from '../zod-schema-Cq_9zlmJ.js';
 import { b as SkillSet } from '../types-HvopERm0.js';
 import { A as AnyTool } from '../tool-DhuBQ3yb.js';
 import { VectorSearchIndex } from '../vector-store/index.js';
@@ -30,6 +32,8 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     private observerRegistrations;
     private dynamicContextRegistrations;
     private dynamicToolRegistrations;
+    private middlewareRegistrations;
+    private memoryRegistration;
     private activeToolSet;
     constructor(agentId: string, completionModel: M);
     name(name: string): this;
@@ -49,7 +53,10 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     toolChoice(toolChoice: ToolChoice): this;
     defaultMaxTurns(defaultMaxTurns: number): this;
     hook(hook: PromptHook): this;
+    toolMiddleware(middleware: ToolMiddleware): this;
+    toolMiddlewares(middlewares: ToolMiddleware[]): this;
     observe(observer: AgentObserver, options?: ObserveOptions): this;
+    memory(store: MemoryStore, options?: MemoryOptions): this;
     outputSchema(schema: ZodSchema): this;
     build(): Agent<M>;
     private buildInstructions;
@@ -67,4 +74,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,11 @@ import {
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-IQBY2GCF.js";
+} from "../chunk-BIJ5ZBCO.js";
+import {
+  resolveMemoryOptions
+} from "../chunk-XXT2UCAR.js";
+import "../chunk-YK4WAAS4.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-GNWMOSNR.js";
 import "../chunk-B4QHQN5K.js";
@@ -18,12 +23,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-D5KKP9_z.d.ts}

@@ -1,6 +1,7 @@
 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 ToolMiddleware, c as ToolSet, b as ToolSearchDocument } from './zod-schema-Cq_9zlmJ.js';
 import { T as Tool, A as AnyTool } from './tool-DhuBQ3yb.js';
 import { VectorSearchIndex, VectorFilter, VectorSearchResult } from './vector-store/index.js';
 
@@ -118,23 +119,30 @@ 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 requestToolMiddlewares;
     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;
+    withToolMiddleware(middleware: ToolMiddleware): this;
+    withToolMiddlewares(middlewares: ToolMiddleware[]): this;
     withTrace(trace: AgentTraceOptions): this;
     send(): Promise<PromptResponse>;
     stream(): AsyncIterable<AgentStreamEvent>;
     readableStream(): ReadableStream<Uint8Array>;
     private runCompletion;
     private executeToolCalls;
+    private runToolResultMiddlewares;
     private startRunObservers;
     private fetchDynamicContext;
     private fetchToolDefinitions;
@@ -142,6 +150,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 +177,8 @@ type AgentOptions<M extends CompletionModel = CompletionModel> = {
     observers?: AgentObserverRegistration[] | undefined;
     dynamicContexts?: DynamicContextRegistration[] | undefined;
     dynamicTools?: DynamicToolRegistration[] | undefined;
+    toolMiddlewares?: ToolMiddleware[] | undefined;
+    memory?: MemoryRegistration | undefined;
 };
 declare const DEFAULT_MAX_TURNS = 20;
 type AgentToolOptions = {
@@ -206,13 +223,29 @@ declare class Agent<M extends CompletionModel = CompletionModel> {
     readonly observers: AgentObserverRegistration[];
     readonly dynamicContexts: DynamicContextRegistration[];
     readonly dynamicTools: DynamicToolRegistration[];
+    readonly toolMiddlewares: ToolMiddleware[];
+    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>;
+    shouldApplyToolMiddleware(toolName: string): boolean;
+}
+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 };