@contractspec/lib.ai-agent 0.0.0-canary-20260113162409

package/dist/interop/types.d.ts

@@ -0,0 +1,262 @@
+import { AgentSpec, AgentToolConfig } from "../spec/spec.js";
+import { ToolHandler } from "../types.js";
+
+//#region src/interop/types.d.ts
+
+/**
+ * Configuration for a spec consumer.
+ */
+interface SpecConsumerConfig {
+  /** Specs to consume */
+  specs: AgentSpec[];
+  /** Whether to include metadata in outputs */
+  includeMetadata?: boolean;
+  /** Base URL for linking */
+  baseUrl?: string;
+}
+/**
+ * Options for markdown generation.
+ */
+interface SpecMarkdownOptions {
+  /** Include table of contents */
+  includeToc?: boolean;
+  /** Include examples */
+  includeExamples?: boolean;
+  /** Include tools section */
+  includeTools?: boolean;
+  /** Include constraints section */
+  includeConstraints?: boolean;
+  /** Custom header */
+  customHeader?: string;
+}
+/**
+ * Options for prompt generation.
+ */
+interface SpecPromptOptions {
+  /** Include tools in prompt */
+  includeTools?: boolean;
+  /** Include examples in prompt */
+  includeExamples?: boolean;
+  /** Include constraints in prompt */
+  includeConstraints?: boolean;
+  /** Output format */
+  format?: 'structured' | 'natural';
+  /** Custom context to append */
+  customContext?: string;
+}
+/**
+ * Result from querying a spec.
+ */
+interface SpecQueryResult {
+  /** Spec key */
+  key: string;
+  /** The spec itself */
+  spec: AgentSpec;
+  /** Markdown representation */
+  markdown: string;
+  /** Prompt representation */
+  prompt: string;
+}
+/**
+ * Options for listing specs.
+ */
+interface SpecListOptions {
+  /** Filter by stability */
+  stability?: string;
+  /** Filter by tags */
+  tags?: string[];
+}
+/**
+ * Result from listing specs.
+ */
+interface SpecListResult {
+  /** Spec key */
+  key: string;
+  /** Spec name (from meta.name or meta.key) */
+  name: string;
+  /** Spec version */
+  version: string;
+  /** Description */
+  description?: string;
+  /** Stability */
+  stability?: string;
+  /** Tags */
+  tags?: string[];
+  /** Number of tools */
+  toolCount: number;
+}
+/**
+ * Interface for spec consumers.
+ */
+interface SpecConsumer {
+  getSpecMarkdown(specKey: string, options?: SpecMarkdownOptions): string;
+  getSpecPrompt(specKey: string, options?: SpecPromptOptions): string;
+  listSpecs(options?: SpecListOptions): SpecListResult[];
+  querySpec(specKey: string): SpecQueryResult | undefined;
+  hasSpec(specKey: string): boolean;
+  getSpec(specKey: string): AgentSpec | undefined;
+  getAllSpecs(): AgentSpec[];
+  getSpecCount(): number;
+  addSpec(spec: AgentSpec): void;
+  removeSpec(specKey: string): boolean;
+}
+/**
+ * Configuration for a tool consumer.
+ */
+interface ToolConsumerConfig {
+  /** Tools with optional handlers */
+  tools: {
+    config: AgentToolConfig;
+    handler?: ToolHandler;
+  }[];
+}
+/**
+ * Configuration for a tool server.
+ */
+interface ToolServerConfig {
+  /** Tools with optional handlers */
+  tools: {
+    config: AgentToolConfig;
+    handler?: ToolHandler;
+  }[];
+  /** Server name */
+  name?: string;
+  /** Server version */
+  version?: string;
+  /** Port to run on */
+  port?: number;
+}
+/**
+ * Interface for tool servers.
+ */
+interface ToolServer {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  isRunning(): boolean;
+  getTools(): AgentToolConfig[];
+}
+/**
+ * Format for tool export.
+ */
+type ToolExportFormat = 'claude-agent' | 'opencode' | 'mcp' | 'openai';
+/**
+ * Interface for tool consumers.
+ */
+interface ToolConsumer {
+  createToolServer(config?: Partial<ToolServerConfig>): ToolServer;
+  exportToolsForSDK(format: ToolExportFormat): unknown[];
+  getTools(): AgentToolConfig[];
+  getTool(name: string): AgentToolConfig | undefined;
+  hasTool(name: string): boolean;
+  addTool(config: AgentToolConfig, handler?: ToolHandler): void;
+  removeTool(name: string): boolean;
+  getToolCount(): number;
+}
+/**
+ * Spec list entry for discovery.
+ */
+interface SpecListEntry {
+  /** Spec key */
+  key: string;
+  /** Spec version */
+  version: string;
+  /** Spec type */
+  type: 'agent' | 'operation' | 'event' | 'presentation';
+  /** Brief description */
+  description?: string;
+  /** Tags for categorization */
+  tags?: string[];
+}
+/**
+ * Task type for implementation prompts.
+ */
+type ImplementationTaskType = 'implement' | 'test' | 'review' | 'refactor' | 'document';
+/**
+ * Options for generating implementation prompts.
+ */
+interface ImplementationPromptOptions {
+  /** Task type */
+  taskType?: ImplementationTaskType;
+  /** Target language/framework */
+  targetLanguage?: string;
+  /** Include examples in prompt */
+  includeExamples?: boolean;
+  /** Include test scenarios */
+  includeTestScenarios?: boolean;
+  /** Custom context to append */
+  customContext?: string;
+}
+/**
+ * Format options for spec export.
+ */
+type SpecExportFormat = 'markdown' | 'json' | 'prompt' | 'context';
+/**
+ * Tool configuration for external consumption.
+ */
+interface ExternalToolConfig {
+  /** Tool name */
+  name: string;
+  /** Tool description */
+  description: string;
+  /** Input schema */
+  inputSchema: Record<string, unknown>;
+  /** Whether approval is required */
+  requiresApproval: boolean;
+  /** Tool category */
+  category?: string;
+}
+/**
+ * Tool handler with metadata.
+ */
+interface ToolWithHandler {
+  /** Tool configuration */
+  config: AgentToolConfig;
+  /** Tool handler function */
+  handler: ToolHandler;
+}
+/**
+ * Target SDK for tool export.
+ */
+type ToolExportTarget = 'claude-agent' | 'opencode' | 'mcp';
+/**
+ * MCP server configuration.
+ */
+interface McpServerConfig {
+  /** Server name */
+  name: string;
+  /** Server description */
+  description?: string;
+  /** Server version */
+  version?: string;
+  /** Tools to expose */
+  tools: AgentToolConfig[];
+  /** Tool handlers */
+  handlers: Map<string, ToolHandler>;
+}
+/**
+ * MCP tool definition for server.
+ */
+interface McpToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+}
+/**
+ * Provider type for UnifiedAgent.
+ */
+type UnifiedAgentProvider = 'ai-sdk' | 'claude-agent-sdk' | 'opencode-sdk';
+/**
+ * Unified agent status.
+ */
+type UnifiedAgentStatus = 'idle' | 'initializing' | 'ready' | 'running' | 'completed' | 'failed';
+/**
+ * Unified agent execution mode.
+ */
+type ExecutionMode = 'generate' | 'stream';
+//#endregion
+export { ExecutionMode, ExternalToolConfig, ImplementationPromptOptions, ImplementationTaskType, McpServerConfig, McpToolDefinition, SpecConsumer, SpecConsumerConfig, SpecExportFormat, SpecListEntry, SpecListOptions, SpecListResult, SpecMarkdownOptions, SpecPromptOptions, SpecQueryResult, ToolConsumer, ToolConsumerConfig, ToolExportFormat, ToolExportTarget, ToolServer, ToolServerConfig, ToolWithHandler, UnifiedAgentProvider, UnifiedAgentStatus };
+//# sourceMappingURL=types.d.ts.map

package/dist/interop/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/interop/types.ts"],"sourcesContent":[],"mappings":";;;;;AA2EA;AAUA;AAoBA;AAC6C,UAzF5B,kBAAA,CAyF4B;EACF;EACrB,KAAA,EAzFb,SAyFa,EAAA;EAAkB;EACV,eAAA,CAAA,EAAA,OAAA;EAEF;EACX,OAAA,CAAA,EAAA,MAAA;;;AAajB;AAWA;AAiBiB,UA5HA,mBAAA,CA4HU;EAChB;EACD,UAAA,CAAA,EAAA,OAAA;EAEI;EAAe,eAAA,CAAA,EAAA,OAAA;EAMjB;EAKK,YAAA,CAAA,EAAY,OAAA;EACO;EAAR,kBAAA,CAAA,EAAA,OAAA;EAA4B;EAC5B,YAAA,CAAA,EAAA,MAAA;;;;;AAI4B,UAjIvC,iBAAA,CAiIuC;EAYvC;EAgBL,YAAA,CAAA,EAAA,OAAA;EAUK;EAgBL,eAAA,CAAA,EAAA,OAAgB;EAKX;EAgBA,kBAAe,CAAA,EAAA,OAAA;EAUpB;EAKK,MAAA,CAAA,EAAA,YAAe,GAAA,SAAA;EAQvB;EAEe,aAAA,CAAA,EAAA,MAAA;;;AAMxB;AAaA;AAQY,UAhPK,eAAA,CAgPa;EAWlB;;;QAvPJ;;;;;;;;;UAUS,eAAA;;;;;;;;;UAUA,cAAA;;;;;;;;;;;;;;;;;;;UAoBA,YAAA;6CAC4B;2CACF;sBACrB,kBAAkB;8BACV;;4BAEF;iBACX;;gBAED;;;;;;UAWC,kBAAA;;;YAGL;cACE;;;;;;UAOG,gBAAA;;;YAGL;cACE;;;;;;;;;;;;UAaG,UAAA;WACN;UACD;;cAEI;;;;;KAMF,gBAAA;;;;UAKK,YAAA;4BACW,QAAQ,oBAAoB;4BAC5B;cACd;yBACW;;kBAEP,2BAA2B;;;;;;;UAY5B,aAAA;;;;;;;;;;;;;;;KAgBL,sBAAA;;;;UAUK,2BAAA;;aAEJ;;;;;;;;;;;;;KAcD,gBAAA;;;;UAKK,kBAAA;;;;;;eAMF;;;;;;;;;UAUE,eAAA;;UAEP;;WAEC;;;;;KAMC,gBAAA;;;;UAKK,eAAA;;;;;;;;SAQR;;YAEG,YAAY;;;;;UAMP,iBAAA;;;;;iBAKA;;;;;;;KAQL,oBAAA;;;;KAQA,kBAAA;;;;KAWA,aAAA"}

package/dist/knowledge/index.d.ts

@@ -0,0 +1,2 @@
+import { createKnowledgeInjector, injectStaticKnowledge } from "./injector.js";
+export { createKnowledgeInjector, injectStaticKnowledge };

package/dist/knowledge/index.js

@@ -0,0 +1,3 @@
+import { createKnowledgeInjector, injectStaticKnowledge } from "./injector.js";
+
+export { createKnowledgeInjector, injectStaticKnowledge };

package/dist/knowledge/injector.d.ts

@@ -0,0 +1,38 @@
+import { AgentKnowledgeRef } from "../spec/spec.js";
+import { KnowledgeRetriever } from "@contractspec/lib.knowledge/retriever";
+
+//#region src/knowledge/injector.d.ts
+
+/**
+ * Inject static knowledge into agent instructions.
+ *
+ * This function handles the "required" knowledge that should be
+ * injected into the system prompt at agent initialization time.
+ * Optional knowledge is handled by the knowledge query tool.
+ *
+ * @param instructions - Base agent instructions
+ * @param knowledgeRefs - Knowledge references from the agent spec
+ * @param retriever - Optional knowledge retriever
+ * @returns Instructions with injected knowledge
+ */
+declare function injectStaticKnowledge(instructions: string, knowledgeRefs: AgentKnowledgeRef[], retriever?: KnowledgeRetriever): Promise<string>;
+/**
+ * Create a knowledge injector instance for reuse.
+ */
+declare function createKnowledgeInjector(retriever?: KnowledgeRetriever): {
+  /**
+   * Inject static knowledge into instructions.
+   */
+  inject: (instructions: string, knowledgeRefs: AgentKnowledgeRef[]) => Promise<string>;
+  /**
+   * Check if a knowledge space is available.
+   */
+  hasSpace: (spaceKey: string) => boolean;
+  /**
+   * List available knowledge spaces.
+   */
+  listSpaces: () => string[];
+};
+//#endregion
+export { createKnowledgeInjector, injectStaticKnowledge };
+//# sourceMappingURL=injector.d.ts.map

package/dist/knowledge/injector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injector.d.ts","names":[],"sources":["../../src/knowledge/injector.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;;;;;AA+CA;;;;;iBA/CsB,qBAAA,sCAEL,iCACH,qBACX;;;;iBA2Ca,uBAAA,aAAoC;;;;gDAKF,wBAAmB"}

package/dist/knowledge/injector.js

@@ -0,0 +1,58 @@
+//#region src/knowledge/injector.ts
+/**
+* Inject static knowledge into agent instructions.
+*
+* This function handles the "required" knowledge that should be
+* injected into the system prompt at agent initialization time.
+* Optional knowledge is handled by the knowledge query tool.
+*
+* @param instructions - Base agent instructions
+* @param knowledgeRefs - Knowledge references from the agent spec
+* @param retriever - Optional knowledge retriever
+* @returns Instructions with injected knowledge
+*/
+async function injectStaticKnowledge(instructions, knowledgeRefs, retriever) {
+	if (!retriever) return instructions;
+	const requiredRefs = knowledgeRefs.filter((ref) => ref.required);
+	if (requiredRefs.length === 0) return instructions;
+	const blocks = [];
+	for (const ref of requiredRefs) {
+		if (!retriever.supportsSpace(ref.key)) {
+			console.warn(`Required knowledge space "${ref.key}" is not available`);
+			continue;
+		}
+		try {
+			const content = await retriever.getStatic(ref.key);
+			if (content) {
+				const header = ref.instructions ? `## ${ref.key}\n${ref.instructions}` : `## ${ref.key}`;
+				blocks.push(`${header}\n\n${content}`);
+			}
+		} catch (error) {
+			console.warn(`Failed to load required knowledge "${ref.key}":`, error);
+		}
+	}
+	if (blocks.length === 0) return instructions;
+	return `${instructions}
+
+---
+
+# Reference Knowledge
+
+The following information is provided for your reference. Use it to inform your responses.
+
+${blocks.join("\n\n---\n\n")}`;
+}
+/**
+* Create a knowledge injector instance for reuse.
+*/
+function createKnowledgeInjector(retriever) {
+	return {
+		inject: (instructions, knowledgeRefs) => injectStaticKnowledge(instructions, knowledgeRefs, retriever),
+		hasSpace: (spaceKey) => retriever?.supportsSpace(spaceKey) ?? false,
+		listSpaces: () => retriever?.listSpaces() ?? []
+	};
+}
+
+//#endregion
+export { createKnowledgeInjector, injectStaticKnowledge };
+//# sourceMappingURL=injector.js.map

package/dist/knowledge/injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injector.js","names":[],"sources":["../../src/knowledge/injector.ts"],"sourcesContent":["import type { KnowledgeRetriever } from '@contractspec/lib.knowledge/retriever';\nimport type { AgentKnowledgeRef } from '../spec/spec';\n\n/**\n * Inject static knowledge into agent instructions.\n *\n * This function handles the \"required\" knowledge that should be\n * injected into the system prompt at agent initialization time.\n * Optional knowledge is handled by the knowledge query tool.\n *\n * @param instructions - Base agent instructions\n * @param knowledgeRefs - Knowledge references from the agent spec\n * @param retriever - Optional knowledge retriever\n * @returns Instructions with injected knowledge\n */\nexport async function injectStaticKnowledge(\n  instructions: string,\n  knowledgeRefs: AgentKnowledgeRef[],\n  retriever?: KnowledgeRetriever\n): Promise<string> {\n  if (!retriever) return instructions;\n\n  const requiredRefs = knowledgeRefs.filter((ref) => ref.required);\n  if (requiredRefs.length === 0) return instructions;\n\n  const blocks: string[] = [];\n\n  for (const ref of requiredRefs) {\n    if (!retriever.supportsSpace(ref.key)) {\n      console.warn(`Required knowledge space \"${ref.key}\" is not available`);\n      continue;\n    }\n\n    try {\n      const content = await retriever.getStatic(ref.key);\n      if (content) {\n        const header = ref.instructions\n          ? `## ${ref.key}\\n${ref.instructions}`\n          : `## ${ref.key}`;\n        blocks.push(`${header}\\n\\n${content}`);\n      }\n    } catch (error) {\n      console.warn(`Failed to load required knowledge \"${ref.key}\":`, error);\n    }\n  }\n\n  if (blocks.length === 0) return instructions;\n\n  return `${instructions}\n\n---\n\n# Reference Knowledge\n\nThe following information is provided for your reference. Use it to inform your responses.\n\n${blocks.join('\\n\\n---\\n\\n')}`;\n}\n\n/**\n * Create a knowledge injector instance for reuse.\n */\nexport function createKnowledgeInjector(retriever?: KnowledgeRetriever) {\n  return {\n    /**\n     * Inject static knowledge into instructions.\n     */\n    inject: (instructions: string, knowledgeRefs: AgentKnowledgeRef[]) =>\n      injectStaticKnowledge(instructions, knowledgeRefs, retriever),\n\n    /**\n     * Check if a knowledge space is available.\n     */\n    hasSpace: (spaceKey: string) => retriever?.supportsSpace(spaceKey) ?? false,\n\n    /**\n     * List available knowledge spaces.\n     */\n    listSpaces: () => retriever?.listSpaces() ?? [],\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,eAAsB,sBACpB,cACA,eACA,WACiB;AACjB,KAAI,CAAC,UAAW,QAAO;CAEvB,MAAM,eAAe,cAAc,QAAQ,QAAQ,IAAI,SAAS;AAChE,KAAI,aAAa,WAAW,EAAG,QAAO;CAEtC,MAAM,SAAmB,EAAE;AAE3B,MAAK,MAAM,OAAO,cAAc;AAC9B,MAAI,CAAC,UAAU,cAAc,IAAI,IAAI,EAAE;AACrC,WAAQ,KAAK,6BAA6B,IAAI,IAAI,oBAAoB;AACtE;;AAGF,MAAI;GACF,MAAM,UAAU,MAAM,UAAU,UAAU,IAAI,IAAI;AAClD,OAAI,SAAS;IACX,MAAM,SAAS,IAAI,eACf,MAAM,IAAI,IAAI,IAAI,IAAI,iBACtB,MAAM,IAAI;AACd,WAAO,KAAK,GAAG,OAAO,MAAM,UAAU;;WAEjC,OAAO;AACd,WAAQ,KAAK,sCAAsC,IAAI,IAAI,KAAK,MAAM;;;AAI1E,KAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAO,GAAG,aAAa;;;;;;;;EAQvB,OAAO,KAAK,cAAc;;;;;AAM5B,SAAgB,wBAAwB,WAAgC;AACtE,QAAO;EAIL,SAAS,cAAsB,kBAC7B,sBAAsB,cAAc,eAAe,UAAU;EAK/D,WAAW,aAAqB,WAAW,cAAc,SAAS,IAAI;EAKtE,kBAAkB,WAAW,YAAY,IAAI,EAAE;EAChD"}

package/dist/memory/in-memory.d.ts

@@ -0,0 +1,22 @@
+import { AgentSessionState } from "../types.js";
+import { AgentMemorySnapshot, AgentSessionMemory, BaseAgentMemoryManager } from "./manager.js";
+
+//#region src/memory/in-memory.d.ts
+interface InMemoryAgentMemoryOptions {
+  ttlMinutes?: number;
+  maxEntries?: number;
+}
+declare class InMemoryAgentMemory extends BaseAgentMemoryManager {
+  private readonly ttlMs;
+  private readonly maxEntries;
+  private readonly store;
+  constructor(options?: InMemoryAgentMemoryOptions);
+  load(sessionId: string): Promise<AgentSessionMemory | null>;
+  save(snapshot: AgentSessionMemory): Promise<void>;
+  summarize(session: AgentSessionState): Promise<AgentMemorySnapshot>;
+  private trim;
+  private evictExpired;
+}
+//#endregion
+export { InMemoryAgentMemory, InMemoryAgentMemoryOptions };
+//# sourceMappingURL=in-memory.d.ts.map

package/dist/memory/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","names":[],"sources":["../../src/memory/in-memory.ts"],"sourcesContent":[],"mappings":";;;;UAaiB,0BAAA;;EAAA,UAAA,CAAA,EAAA,MAAA;AAKjB;AAKwB,cALX,mBAAA,SAA4B,sBAAA,CAKjB;EAMiB,iBAAA,KAAA;EAAR,iBAAA,UAAA;EASV,iBAAA,KAAA;EAAqB,WAAA,CAAA,OAAA,CAAA,EAfpB,0BAeoB;EAQjB,IAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EAjBM,OAiBN,CAjBc,kBAiBd,GAAA,IAAA,CAAA;EAA4B,IAAA,CAAA,QAAA,EARhC,kBAQgC,CAAA,EARX,OAQW,CAAA,IAAA,CAAA;EAAR,SAAA,CAAA,OAAA,EAApB,iBAAoB,CAAA,EAAA,OAAA,CAAQ,mBAAR,CAAA;EA5BN,QAAA,IAAA;EAAsB,QAAA,YAAA"}

package/dist/memory/in-memory.js

@@ -0,0 +1,48 @@
+import { BaseAgentMemoryManager } from "./manager.js";
+
+//#region src/memory/in-memory.ts
+var InMemoryAgentMemory = class extends BaseAgentMemoryManager {
+	ttlMs;
+	maxEntries;
+	store = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super();
+		this.ttlMs = (options?.ttlMinutes ?? 60) * 60 * 1e3;
+		this.maxEntries = options?.maxEntries ?? 250;
+	}
+	async load(sessionId) {
+		this.evictExpired();
+		const stored = this.store.get(sessionId);
+		if (!stored) return null;
+		stored.data.session.updatedAt = /* @__PURE__ */ new Date();
+		stored.expiresAt = Date.now() + this.ttlMs;
+		return stored.data;
+	}
+	async save(snapshot) {
+		this.trim(snapshot.memory.entries);
+		this.store.set(snapshot.session.sessionId, {
+			data: snapshot,
+			expiresAt: Date.now() + this.ttlMs
+		});
+	}
+	async summarize(session) {
+		const current = await this.load(session.sessionId) ?? this.bootstrapMemory(session);
+		const content = current.memory.entries.slice(-10).map((entry) => `- ${entry.type}: ${entry.content}`).join("\n");
+		current.memory.summary = content;
+		current.memory.lastSummarizedAt = /* @__PURE__ */ new Date();
+		await this.save(current);
+		return current.memory;
+	}
+	trim(entries) {
+		if (entries.length <= this.maxEntries) return;
+		entries.splice(0, entries.length - this.maxEntries);
+	}
+	evictExpired() {
+		const now = Date.now();
+		for (const [sessionId, stored] of this.store.entries()) if (stored.expiresAt <= now) this.store.delete(sessionId);
+	}
+};
+
+//#endregion
+export { InMemoryAgentMemory };
+//# sourceMappingURL=in-memory.js.map

package/dist/memory/in-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.js","names":[],"sources":["../../src/memory/in-memory.ts"],"sourcesContent":["import type { AgentSessionState } from '../types';\nimport {\n  BaseAgentMemoryManager,\n  type AgentMemoryEntry,\n  type AgentMemorySnapshot,\n  type AgentSessionMemory,\n} from './manager';\n\ninterface StoredSession {\n  data: AgentSessionMemory;\n  expiresAt: number;\n}\n\nexport interface InMemoryAgentMemoryOptions {\n  ttlMinutes?: number;\n  maxEntries?: number;\n}\n\nexport class InMemoryAgentMemory extends BaseAgentMemoryManager {\n  private readonly ttlMs: number;\n  private readonly maxEntries: number;\n  private readonly store = new Map<string, StoredSession>();\n\n  constructor(options?: InMemoryAgentMemoryOptions) {\n    super();\n    this.ttlMs = (options?.ttlMinutes ?? 60) * 60 * 1000;\n    this.maxEntries = options?.maxEntries ?? 250;\n  }\n\n  async load(sessionId: string): Promise<AgentSessionMemory | null> {\n    this.evictExpired();\n    const stored = this.store.get(sessionId);\n    if (!stored) return null;\n    stored.data.session.updatedAt = new Date();\n    stored.expiresAt = Date.now() + this.ttlMs;\n    return stored.data;\n  }\n\n  async save(snapshot: AgentSessionMemory): Promise<void> {\n    this.trim(snapshot.memory.entries);\n    this.store.set(snapshot.session.sessionId, {\n      data: snapshot,\n      expiresAt: Date.now() + this.ttlMs,\n    });\n  }\n\n  async summarize(session: AgentSessionState): Promise<AgentMemorySnapshot> {\n    const current =\n      (await this.load(session.sessionId)) ?? this.bootstrapMemory(session);\n    const content = current.memory.entries\n      .slice(-10)\n      .map((entry) => `- ${entry.type}: ${entry.content}`)\n      .join('\\n');\n    current.memory.summary = content;\n    current.memory.lastSummarizedAt = new Date();\n    await this.save(current);\n    return current.memory;\n  }\n\n  private trim(entries: AgentMemoryEntry[]) {\n    if (entries.length <= this.maxEntries) return;\n    entries.splice(0, entries.length - this.maxEntries);\n  }\n\n  private evictExpired() {\n    const now = Date.now();\n    for (const [sessionId, stored] of this.store.entries()) {\n      if (stored.expiresAt <= now) {\n        this.store.delete(sessionId);\n      }\n    }\n  }\n}\n"],"mappings":";;;AAkBA,IAAa,sBAAb,cAAyC,uBAAuB;CAC9D,AAAiB;CACjB,AAAiB;CACjB,AAAiB,wBAAQ,IAAI,KAA4B;CAEzD,YAAY,SAAsC;AAChD,SAAO;AACP,OAAK,SAAS,SAAS,cAAc,MAAM,KAAK;AAChD,OAAK,aAAa,SAAS,cAAc;;CAG3C,MAAM,KAAK,WAAuD;AAChE,OAAK,cAAc;EACnB,MAAM,SAAS,KAAK,MAAM,IAAI,UAAU;AACxC,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,QAAQ,4BAAY,IAAI,MAAM;AAC1C,SAAO,YAAY,KAAK,KAAK,GAAG,KAAK;AACrC,SAAO,OAAO;;CAGhB,MAAM,KAAK,UAA6C;AACtD,OAAK,KAAK,SAAS,OAAO,QAAQ;AAClC,OAAK,MAAM,IAAI,SAAS,QAAQ,WAAW;GACzC,MAAM;GACN,WAAW,KAAK,KAAK,GAAG,KAAK;GAC9B,CAAC;;CAGJ,MAAM,UAAU,SAA0D;EACxE,MAAM,UACH,MAAM,KAAK,KAAK,QAAQ,UAAU,IAAK,KAAK,gBAAgB,QAAQ;EACvE,MAAM,UAAU,QAAQ,OAAO,QAC5B,MAAM,IAAI,CACV,KAAK,UAAU,KAAK,MAAM,KAAK,IAAI,MAAM,UAAU,CACnD,KAAK,KAAK;AACb,UAAQ,OAAO,UAAU;AACzB,UAAQ,OAAO,mCAAmB,IAAI,MAAM;AAC5C,QAAM,KAAK,KAAK,QAAQ;AACxB,SAAO,QAAQ;;CAGjB,AAAQ,KAAK,SAA6B;AACxC,MAAI,QAAQ,UAAU,KAAK,WAAY;AACvC,UAAQ,OAAO,GAAG,QAAQ,SAAS,KAAK,WAAW;;CAGrD,AAAQ,eAAe;EACrB,MAAM,MAAM,KAAK,KAAK;AACtB,OAAK,MAAM,CAAC,WAAW,WAAW,KAAK,MAAM,SAAS,CACpD,KAAI,OAAO,aAAa,IACtB,MAAK,MAAM,OAAO,UAAU"}

package/dist/memory/index.d.ts

@@ -0,0 +1,3 @@
+import { AgentMemoryEntry, AgentMemoryManager, AgentMemorySnapshot, AgentSessionMemory, BaseAgentMemoryManager, trackMessageInMemory } from "./manager.js";
+import { InMemoryAgentMemory, InMemoryAgentMemoryOptions } from "./in-memory.js";
+export { AgentMemoryEntry, AgentMemoryManager, AgentMemorySnapshot, AgentSessionMemory, BaseAgentMemoryManager, InMemoryAgentMemory, InMemoryAgentMemoryOptions, trackMessageInMemory };

package/dist/memory/index.js

@@ -0,0 +1,4 @@
+import { BaseAgentMemoryManager, trackMessageInMemory } from "./manager.js";
+import { InMemoryAgentMemory } from "./in-memory.js";
+
+export { BaseAgentMemoryManager, InMemoryAgentMemory, trackMessageInMemory };

package/dist/memory/manager.d.ts

@@ -0,0 +1,42 @@
+import { AgentMessage, AgentSessionState } from "../types.js";
+
+//#region src/memory/manager.d.ts
+interface AgentMemoryEntry {
+  id: string;
+  type: 'user' | 'assistant' | 'tool' | 'system';
+  content: string;
+  createdAt: Date;
+  metadata?: Record<string, string>;
+}
+interface AgentMemorySnapshot {
+  entries: AgentMemoryEntry[];
+  summary?: string;
+  lastSummarizedAt?: Date;
+}
+interface AgentSessionMemory {
+  session: AgentSessionState;
+  memory: AgentMemorySnapshot;
+}
+interface AgentMemoryManager {
+  load(sessionId: string): Promise<AgentSessionMemory | null>;
+  save(snapshot: AgentSessionMemory): Promise<void>;
+  append(session: AgentSessionState, entry: Omit<AgentMemoryEntry, 'id' | 'createdAt'> & {
+    createdAt?: Date;
+  }): Promise<AgentSessionMemory>;
+  summarize(session: AgentSessionState): Promise<AgentMemorySnapshot | undefined>;
+  prune(session: AgentSessionState): Promise<void>;
+}
+declare abstract class BaseAgentMemoryManager implements AgentMemoryManager {
+  abstract load(sessionId: string): Promise<AgentSessionMemory | null>;
+  abstract save(snapshot: AgentSessionMemory): Promise<void>;
+  append(session: AgentSessionState, entry: Omit<AgentMemoryEntry, 'id' | 'createdAt'> & {
+    createdAt?: Date;
+  }): Promise<AgentSessionMemory>;
+  summarize(_session: AgentSessionState): Promise<AgentMemorySnapshot | undefined>;
+  prune(_session: AgentSessionState): Promise<void>;
+  protected bootstrapMemory(session: AgentSessionState): AgentSessionMemory;
+}
+declare function trackMessageInMemory(manager: AgentMemoryManager | undefined, session: AgentSessionState, message: AgentMessage): void;
+//#endregion
+export { AgentMemoryEntry, AgentMemoryManager, AgentMemorySnapshot, AgentSessionMemory, BaseAgentMemoryManager, trackMessageInMemory };
+//# sourceMappingURL=manager.d.ts.map

package/dist/memory/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","names":[],"sources":["../../src/memory/manager.ts"],"sourcesContent":[],"mappings":";;;UAIiB,gBAAA;;EAAA,IAAA,EAAA,MAAA,GAAA,WAAgB,GAAA,MAIpB,GACA,QAAM;EAGF,OAAA,EAAA,MAAA;EAMA,SAAA,EAVJ,IAUI;EAKA,QAAA,CAAA,EAdJ,MAcI,CAAA,MAAkB,EAAA,MAAA,CAAA;;AACR,UAZV,mBAAA,CAYU;EACV,OAAA,EAZN,gBAYM,EAAA;EAAqB,OAAA,CAAA,EAAA,MAAA;EAEzB,gBAAA,CAAA,EAZQ,IAYR;;AACF,UAVM,kBAAA,CAUN;EAA2D,OAAA,EAT3D,iBAS2D;EACzD,MAAA,EATH,mBASG;;AAEA,UARI,kBAAA,CAQJ;EACA,IAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EARc,OAQd,CARsB,kBAQtB,GAAA,IAAA,CAAA;EAAR,IAAA,CAAA,QAAA,EAPY,kBAOZ,CAAA,EAPiC,OAOjC,CAAA,IAAA,CAAA;EACY,MAAA,CAAA,OAAA,EANJ,iBAMI,EAAA,KAAA,EALN,IAKM,CALD,gBAKC,EAAA,IAAA,GAAA,WAAA,CAAA,GAAA;IAAoB,SAAA,CAAA,EALiC,IAKjC;EAAO,CAAA,CAAA,EAJvC,OAIuC,CAJ/B,kBAI+B,CAAA;EAyEtB,SAAA,CAAA,OAAA,EA3ET,iBA2EgC,CAAA,EA1ExC,OA0EwC,CA1EhC,mBA0EgC,GAAA,SAAA,CAAA;EACD,KAAA,CAAA,OAAA,EA1E3B,iBA0E2B,CAAA,EA1EP,OA0EO,CAAA,IAAA,CAAA;;AAClB,uBAFJ,sBAAA,YAAkC,kBAE9B,CAAA;EAAqB,SAAA,IAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EADX,OACW,CADH,kBACG,GAAA,IAAA,CAAA;EAGlC,SAAA,IAAA,CAAA,QAAA,EAHa,kBAGb,CAAA,EAHkC,OAGlC,CAAA,IAAA,CAAA;EACG,MAAA,CAAA,OAAA,EADH,iBACG,EAAA,KAAA,EAAL,IAAK,CAAA,gBAAA,EAAA,IAAA,GAAA,WAAA,CAAA,GAAA;IAAL,SAAA,CAAA,EAA2D,IAA3D;EAA2D,CAAA,CAAA,EACjE,OADiE,CACzD,kBADyD,CAAA;EACzD,SAAA,CAAA,QAAA,EAcC,iBAdD,CAAA,EAeR,OAfQ,CAeA,mBAfA,GAAA,SAAA,CAAA;EAAR,KAAA,CAAA,QAAA,EAmBmB,iBAnBnB,CAAA,EAmBuC,OAnBvC,CAAA,IAAA,CAAA;EAcS,UAAA,eAAA,CAAA,OAAA,EASuB,iBATvB,CAAA,EAS2C,kBAT3C;;AACT,iBAuBW,oBAAA,CAvBX,OAAA,EAwBM,kBAxBN,GAAA,SAAA,EAAA,OAAA,EAyBM,iBAzBN,EAAA,OAAA,EA0BM,YA1BN,CAAA,EAAA,IAAA"}

package/dist/memory/manager.js

@@ -0,0 +1,80 @@
+import { randomUUID } from "node:crypto";
+
+//#region src/memory/manager.ts
+/**
+* Extract text content from a ModelMessage.
+* Handles both string content and array content parts.
+*/
+function extractMessageContent(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => {
+		if (typeof part === "string") return part;
+		if ("text" in part && typeof part.text === "string") return part.text;
+		return "";
+	}).filter(Boolean).join("");
+	return "";
+}
+/**
+* Extract text content from an AgentMessage.
+*/
+function extractAgentMessageContent(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => {
+		if (typeof part === "string") return part;
+		if ("text" in part && typeof part.text === "string") return part.text;
+		return "";
+	}).filter(Boolean).join("");
+	return "";
+}
+/**
+* Map ModelMessage role to memory entry type.
+*/
+function roleToEntryType(role) {
+	switch (role) {
+		case "assistant": return "assistant";
+		case "system": return "system";
+		case "tool": return "tool";
+		case "user":
+		default: return "user";
+	}
+}
+var BaseAgentMemoryManager = class {
+	async append(session, entry) {
+		const current = await this.load(session.sessionId) ?? this.bootstrapMemory(session);
+		const finalEntry = {
+			id: randomUUID(),
+			createdAt: entry.createdAt ?? /* @__PURE__ */ new Date(),
+			...entry
+		};
+		current.memory.entries.push(finalEntry);
+		await this.save(current);
+		return current;
+	}
+	async summarize(_session) {}
+	async prune(_session) {}
+	bootstrapMemory(session) {
+		return {
+			session,
+			memory: { entries: session.messages.map((message) => ({
+				id: randomUUID(),
+				createdAt: /* @__PURE__ */ new Date(),
+				type: roleToEntryType(message.role),
+				content: extractMessageContent(message)
+			})) }
+		};
+	}
+};
+function trackMessageInMemory(manager, session, message) {
+	if (!manager) return;
+	manager.append(session, {
+		type: message.role,
+		content: extractAgentMessageContent(message),
+		metadata: message.metadata
+	});
+}
+
+//#endregion
+export { BaseAgentMemoryManager, trackMessageInMemory };
+//# sourceMappingURL=manager.js.map

package/dist/memory/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","names":[],"sources":["../../src/memory/manager.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { ModelMessage } from 'ai';\nimport type { AgentMessage, AgentSessionState } from '../types';\n\nexport interface AgentMemoryEntry {\n  id: string;\n  type: 'user' | 'assistant' | 'tool' | 'system';\n  content: string;\n  createdAt: Date;\n  metadata?: Record<string, string>;\n}\n\nexport interface AgentMemorySnapshot {\n  entries: AgentMemoryEntry[];\n  summary?: string;\n  lastSummarizedAt?: Date;\n}\n\nexport interface AgentSessionMemory {\n  session: AgentSessionState;\n  memory: AgentMemorySnapshot;\n}\n\nexport interface AgentMemoryManager {\n  load(sessionId: string): Promise<AgentSessionMemory | null>;\n  save(snapshot: AgentSessionMemory): Promise<void>;\n  append(\n    session: AgentSessionState,\n    entry: Omit<AgentMemoryEntry, 'id' | 'createdAt'> & { createdAt?: Date }\n  ): Promise<AgentSessionMemory>;\n  summarize(\n    session: AgentSessionState\n  ): Promise<AgentMemorySnapshot | undefined>;\n  prune(session: AgentSessionState): Promise<void>;\n}\n\n/**\n * Extract text content from a ModelMessage.\n * Handles both string content and array content parts.\n */\nfunction extractMessageContent(message: ModelMessage): string {\n  const content = message.content;\n\n  // Handle string content directly\n  if (typeof content === 'string') {\n    return content;\n  }\n\n  // Handle array content (parts)\n  if (Array.isArray(content)) {\n    return content\n      .map((part) => {\n        if (typeof part === 'string') return part;\n        if ('text' in part && typeof part.text === 'string') return part.text;\n        return '';\n      })\n      .filter(Boolean)\n      .join('');\n  }\n\n  return '';\n}\n\n/**\n * Extract text content from an AgentMessage.\n */\nfunction extractAgentMessageContent(message: AgentMessage): string {\n  const content = message.content;\n\n  if (typeof content === 'string') {\n    return content;\n  }\n\n  if (Array.isArray(content)) {\n    return content\n      .map((part) => {\n        if (typeof part === 'string') return part;\n        if ('text' in part && typeof part.text === 'string') return part.text;\n        return '';\n      })\n      .filter(Boolean)\n      .join('');\n  }\n\n  return '';\n}\n\n/**\n * Map ModelMessage role to memory entry type.\n */\nfunction roleToEntryType(\n  role: ModelMessage['role']\n): 'user' | 'assistant' | 'tool' | 'system' {\n  switch (role) {\n    case 'assistant':\n      return 'assistant';\n    case 'system':\n      return 'system';\n    case 'tool':\n      return 'tool';\n    case 'user':\n    default:\n      return 'user';\n  }\n}\n\nexport abstract class BaseAgentMemoryManager implements AgentMemoryManager {\n  abstract load(sessionId: string): Promise<AgentSessionMemory | null>;\n  abstract save(snapshot: AgentSessionMemory): Promise<void>;\n\n  async append(\n    session: AgentSessionState,\n    entry: Omit<AgentMemoryEntry, 'id' | 'createdAt'> & { createdAt?: Date }\n  ): Promise<AgentSessionMemory> {\n    const current =\n      (await this.load(session.sessionId)) ?? this.bootstrapMemory(session);\n    const finalEntry: AgentMemoryEntry = {\n      id: randomUUID(),\n      createdAt: entry.createdAt ?? new Date(),\n      ...entry,\n    };\n    current.memory.entries.push(finalEntry);\n    await this.save(current);\n    return current;\n  }\n\n  async summarize(\n    _session: AgentSessionState\n  ): Promise<AgentMemorySnapshot | undefined> {\n    return undefined;\n  }\n\n  async prune(_session: AgentSessionState): Promise<void> {\n    // noop by default\n  }\n\n  protected bootstrapMemory(session: AgentSessionState): AgentSessionMemory {\n    return {\n      session,\n      memory: {\n        entries: session.messages.map<AgentMemoryEntry>((message) => ({\n          id: randomUUID(),\n          createdAt: new Date(),\n          type: roleToEntryType(message.role),\n          content: extractMessageContent(message),\n        })),\n      },\n    };\n  }\n}\n\nexport function trackMessageInMemory(\n  manager: AgentMemoryManager | undefined,\n  session: AgentSessionState,\n  message: AgentMessage\n) {\n  if (!manager) return;\n  void manager.append(session, {\n    type: message.role,\n    content: extractAgentMessageContent(message),\n    metadata: message.metadata,\n  });\n}\n"],"mappings":";;;;;;;AAwCA,SAAS,sBAAsB,SAA+B;CAC5D,MAAM,UAAU,QAAQ;AAGxB,KAAI,OAAO,YAAY,SACrB,QAAO;AAIT,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QACJ,KAAK,SAAS;AACb,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,MAAI,UAAU,QAAQ,OAAO,KAAK,SAAS,SAAU,QAAO,KAAK;AACjE,SAAO;GACP,CACD,OAAO,QAAQ,CACf,KAAK,GAAG;AAGb,QAAO;;;;;AAMT,SAAS,2BAA2B,SAA+B;CACjE,MAAM,UAAU,QAAQ;AAExB,KAAI,OAAO,YAAY,SACrB,QAAO;AAGT,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QACJ,KAAK,SAAS;AACb,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,MAAI,UAAU,QAAQ,OAAO,KAAK,SAAS,SAAU,QAAO,KAAK;AACjE,SAAO;GACP,CACD,OAAO,QAAQ,CACf,KAAK,GAAG;AAGb,QAAO;;;;;AAMT,SAAS,gBACP,MAC0C;AAC1C,SAAQ,MAAR;EACE,KAAK,YACH,QAAO;EACT,KAAK,SACH,QAAO;EACT,KAAK,OACH,QAAO;EACT,KAAK;EACL,QACE,QAAO;;;AAIb,IAAsB,yBAAtB,MAA2E;CAIzE,MAAM,OACJ,SACA,OAC6B;EAC7B,MAAM,UACH,MAAM,KAAK,KAAK,QAAQ,UAAU,IAAK,KAAK,gBAAgB,QAAQ;EACvE,MAAM,aAA+B;GACnC,IAAI,YAAY;GAChB,WAAW,MAAM,6BAAa,IAAI,MAAM;GACxC,GAAG;GACJ;AACD,UAAQ,OAAO,QAAQ,KAAK,WAAW;AACvC,QAAM,KAAK,KAAK,QAAQ;AACxB,SAAO;;CAGT,MAAM,UACJ,UAC0C;CAI5C,MAAM,MAAM,UAA4C;CAIxD,AAAU,gBAAgB,SAAgD;AACxE,SAAO;GACL;GACA,QAAQ,EACN,SAAS,QAAQ,SAAS,KAAuB,aAAa;IAC5D,IAAI,YAAY;IAChB,2BAAW,IAAI,MAAM;IACrB,MAAM,gBAAgB,QAAQ,KAAK;IACnC,SAAS,sBAAsB,QAAQ;IACxC,EAAE,EACJ;GACF;;;AAIL,SAAgB,qBACd,SACA,SACA,SACA;AACA,KAAI,CAAC,QAAS;AACd,CAAK,QAAQ,OAAO,SAAS;EAC3B,MAAM,QAAQ;EACd,SAAS,2BAA2B,QAAQ;EAC5C,UAAU,QAAQ;EACnB,CAAC"}