@od-oneapp/ai-platform 0.1.0

package/dist/agents-persistence.d.mts

@@ -0,0 +1,234 @@
+import { n as RedisClientExtended } from "./types-By-r93bE.mjs";
+import { z } from "zod";
+
+//#region src/agents/persistence/index.d.ts
+declare namespace index_d_exports {
+  export { AgentCheckpoint, AgentCheckpointSchema, AgentMessage, AgentMessageSchema, CheckpointManagerConfig, CheckpointState, CheckpointStateSchema, CheckpointStore, ListOptions, RedisClientExtended as RedisClient, ToolCallRecord, ToolCallRecordSchema, addMessage, completeToolCall, createCheckpointManager, createInitialState, createMemoryCheckpointStore, createRedisCheckpointStore, mergeTokenUsage, recordToolCall, updateStatus };
+}
+interface AgentCheckpoint {
+  id: string;
+  agentId: string;
+  version: number;
+  state: CheckpointState;
+  createdAt: Date;
+  expiresAt?: Date;
+  parentId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface CheckpointState {
+  messages: AgentMessage[];
+  currentStep: number;
+  totalSteps: number;
+  toolCalls: ToolCallRecord[];
+  pendingApprovals: string[];
+  customState: Record<string, unknown>;
+  tokenUsage: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  costUsd: number;
+  status: 'running' | 'paused' | 'completed' | 'failed' | 'waiting_approval';
+  error?: {
+    message: string;
+    code?: string;
+    stack?: string;
+  };
+}
+interface AgentMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  toolCallId?: string;
+  createdAt: Date;
+}
+interface ToolCallRecord {
+  id: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  result?: unknown;
+  error?: string;
+  startedAt: Date;
+  completedAt?: Date;
+  approved?: boolean;
+  approvedBy?: string;
+}
+interface CheckpointStore {
+  save(checkpoint: AgentCheckpoint): Promise<void>;
+  load(checkpointId: string): Promise<AgentCheckpoint | null>;
+  loadLatest(agentId: string): Promise<AgentCheckpoint | null>;
+  list(agentId: string, options?: ListOptions): Promise<AgentCheckpoint[]>;
+  delete(checkpointId: string): Promise<void>;
+  deleteAll(agentId: string): Promise<void>;
+  exists(checkpointId: string): Promise<boolean>;
+}
+interface ListOptions {
+  limit?: number;
+  offset?: number;
+  before?: Date;
+  after?: Date;
+}
+declare const AgentMessageSchema: z.ZodObject<{
+  id: z.ZodString;
+  role: z.ZodEnum<{
+    user: "user";
+    assistant: "assistant";
+    system: "system";
+    tool: "tool";
+  }>;
+  content: z.ZodString;
+  toolCallId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodDate;
+}, z.core.$strip>;
+declare const ToolCallRecordSchema: z.ZodObject<{
+  id: z.ZodString;
+  toolName: z.ZodString;
+  args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  result: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<z.ZodString>;
+  startedAt: z.ZodDate;
+  completedAt: z.ZodOptional<z.ZodDate>;
+  approved: z.ZodOptional<z.ZodBoolean>;
+  approvedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CheckpointStateSchema: z.ZodObject<{
+  messages: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+      system: "system";
+      tool: "tool";
+    }>;
+    content: z.ZodString;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDate;
+  }, z.core.$strip>>;
+  currentStep: z.ZodNumber;
+  totalSteps: z.ZodNumber;
+  toolCalls: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    toolName: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    approvedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  pendingApprovals: z.ZodArray<z.ZodString>;
+  customState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  tokenUsage: z.ZodObject<{
+    promptTokens: z.ZodNumber;
+    completionTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+  }, z.core.$strip>;
+  costUsd: z.ZodNumber;
+  status: z.ZodEnum<{
+    running: "running";
+    paused: "paused";
+    completed: "completed";
+    failed: "failed";
+    waiting_approval: "waiting_approval";
+  }>;
+  error: z.ZodOptional<z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    stack: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AgentCheckpointSchema: z.ZodObject<{
+  id: z.ZodString;
+  agentId: z.ZodString;
+  version: z.ZodNumber;
+  state: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        system: "system";
+        tool: "tool";
+      }>;
+      content: z.ZodString;
+      toolCallId: z.ZodOptional<z.ZodString>;
+      createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    currentStep: z.ZodNumber;
+    totalSteps: z.ZodNumber;
+    toolCalls: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      toolName: z.ZodString;
+      args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      result: z.ZodOptional<z.ZodUnknown>;
+      error: z.ZodOptional<z.ZodString>;
+      startedAt: z.ZodDate;
+      completedAt: z.ZodOptional<z.ZodDate>;
+      approved: z.ZodOptional<z.ZodBoolean>;
+      approvedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    pendingApprovals: z.ZodArray<z.ZodString>;
+    customState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tokenUsage: z.ZodObject<{
+      promptTokens: z.ZodNumber;
+      completionTokens: z.ZodNumber;
+      totalTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    costUsd: z.ZodNumber;
+    status: z.ZodEnum<{
+      running: "running";
+      paused: "paused";
+      completed: "completed";
+      failed: "failed";
+      waiting_approval: "waiting_approval";
+    }>;
+    error: z.ZodOptional<z.ZodObject<{
+      message: z.ZodString;
+      code: z.ZodOptional<z.ZodString>;
+      stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  createdAt: z.ZodDate;
+  expiresAt: z.ZodOptional<z.ZodDate>;
+  parentId: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare function createMemoryCheckpointStore(): CheckpointStore;
+declare function createRedisCheckpointStore(redis: RedisClientExtended, options?: {
+  prefix?: string;
+  defaultTTL?: number;
+}): CheckpointStore;
+interface CheckpointManagerConfig {
+  store: CheckpointStore;
+  autoCheckpointInterval?: number;
+  maxCheckpointsPerAgent?: number;
+  version?: number;
+  defaultTTL?: number;
+}
+declare function createCheckpointManager(config: CheckpointManagerConfig): {
+  checkpoint(agentId: string, state: CheckpointState, options?: {
+    force?: boolean;
+    metadata?: Record<string, unknown>;
+  }): Promise<AgentCheckpoint>;
+  maybeCheckpoint(agentId: string, state: CheckpointState, options?: {
+    metadata?: Record<string, unknown>;
+  }): Promise<AgentCheckpoint | null>;
+  restore(agentId: string): Promise<CheckpointState | null>;
+  restoreFrom(checkpointId: string): Promise<CheckpointState | null>;
+  list(agentId: string, options?: ListOptions): Promise<AgentCheckpoint[]>;
+  cleanup(agentId: string): Promise<void>;
+  getStore(): CheckpointStore;
+};
+declare function createInitialState(customState?: Record<string, unknown>): CheckpointState;
+declare function mergeTokenUsage(state: CheckpointState, usage: {
+  promptTokens?: number;
+  completionTokens?: number;
+}): CheckpointState;
+declare function addMessage(state: CheckpointState, message: Omit<AgentMessage, 'id' | 'createdAt'>): CheckpointState;
+declare function recordToolCall(state: CheckpointState, toolCall: Omit<ToolCallRecord, 'id' | 'startedAt'>): CheckpointState;
+declare function completeToolCall(state: CheckpointState, toolCallId: string, result: unknown, error?: string): CheckpointState;
+declare function updateStatus(state: CheckpointState, status: CheckpointState['status'], error?: CheckpointState['error']): CheckpointState;
+//#endregion
+export { AgentCheckpoint, AgentCheckpointSchema, AgentMessage, AgentMessageSchema, CheckpointManagerConfig, CheckpointState, CheckpointStateSchema, CheckpointStore, ListOptions, type RedisClientExtended as RedisClient, ToolCallRecord, ToolCallRecordSchema, addMessage, completeToolCall, createCheckpointManager, createInitialState, createMemoryCheckpointStore, createRedisCheckpointStore, mergeTokenUsage, recordToolCall, index_d_exports as t, updateStatus };
+//# sourceMappingURL=agents-persistence.d.mts.map

package/dist/agents-persistence.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-persistence.d.mts","names":[],"sources":["../src/agents/persistence/index.ts"],"mappings":"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"}

package/dist/agents-persistence.mjs

@@ -0,0 +1,447 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { z } from "zod";
+
+//#region src/agents/persistence/index.ts
+/**
+* Agent State Persistence & Checkpointing
+*
+* Provides durable state management for agents, enabling crash recovery,
+* long-running workflows, and resumable operations.
+*
+* @module @od-oneapp/ai-platform/agents/persistence
+*/
+var persistence_exports = /* @__PURE__ */ __exportAll({
+	AgentCheckpointSchema: () => AgentCheckpointSchema,
+	AgentMessageSchema: () => AgentMessageSchema,
+	CheckpointStateSchema: () => CheckpointStateSchema,
+	ToolCallRecordSchema: () => ToolCallRecordSchema,
+	addMessage: () => addMessage,
+	completeToolCall: () => completeToolCall,
+	createCheckpointManager: () => createCheckpointManager,
+	createInitialState: () => createInitialState,
+	createMemoryCheckpointStore: () => createMemoryCheckpointStore,
+	createRedisCheckpointStore: () => createRedisCheckpointStore,
+	mergeTokenUsage: () => mergeTokenUsage,
+	recordToolCall: () => recordToolCall,
+	updateStatus: () => updateStatus
+});
+const AgentMessageSchema = z.object({
+	id: z.string(),
+	role: z.enum([
+		"user",
+		"assistant",
+		"system",
+		"tool"
+	]),
+	content: z.string(),
+	toolCallId: z.string().optional(),
+	createdAt: z.date()
+});
+const ToolCallRecordSchema = z.object({
+	id: z.string(),
+	toolName: z.string(),
+	args: z.record(z.string(), z.unknown()),
+	result: z.unknown().optional(),
+	error: z.string().optional(),
+	startedAt: z.date(),
+	completedAt: z.date().optional(),
+	approved: z.boolean().optional(),
+	approvedBy: z.string().optional()
+});
+const CheckpointStateSchema = z.object({
+	messages: z.array(AgentMessageSchema),
+	currentStep: z.number(),
+	totalSteps: z.number(),
+	toolCalls: z.array(ToolCallRecordSchema),
+	pendingApprovals: z.array(z.string()),
+	customState: z.record(z.string(), z.unknown()),
+	tokenUsage: z.object({
+		promptTokens: z.number(),
+		completionTokens: z.number(),
+		totalTokens: z.number()
+	}),
+	costUsd: z.number(),
+	status: z.enum([
+		"running",
+		"paused",
+		"completed",
+		"failed",
+		"waiting_approval"
+	]),
+	error: z.object({
+		message: z.string(),
+		code: z.string().optional(),
+		stack: z.string().optional()
+	}).optional()
+});
+const AgentCheckpointSchema = z.object({
+	id: z.string(),
+	agentId: z.string(),
+	version: z.number(),
+	state: CheckpointStateSchema,
+	createdAt: z.date(),
+	expiresAt: z.date().optional(),
+	parentId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Create an in-memory checkpoint store
+*
+* Useful for development and testing. Not suitable for production
+* as checkpoints are lost on restart.
+*
+* @example
+* ```typescript
+* const store = createMemoryCheckpointStore();
+* await store.save(checkpoint);
+* const loaded = await store.load(checkpoint.id);
+* ```
+*/
+function createMemoryCheckpointStore() {
+	const checkpoints = /* @__PURE__ */ new Map();
+	const agentIndex = /* @__PURE__ */ new Map();
+	return {
+		async save(checkpoint) {
+			checkpoints.set(checkpoint.id, { ...checkpoint });
+			let ids = agentIndex.get(checkpoint.agentId);
+			if (!ids) {
+				ids = /* @__PURE__ */ new Set();
+				agentIndex.set(checkpoint.agentId, ids);
+			}
+			ids.add(checkpoint.id);
+		},
+		async load(checkpointId) {
+			const checkpoint = checkpoints.get(checkpointId);
+			if (!checkpoint) return null;
+			if (checkpoint.expiresAt && checkpoint.expiresAt < /* @__PURE__ */ new Date()) {
+				checkpoints.delete(checkpointId);
+				return null;
+			}
+			return { ...checkpoint };
+		},
+		async loadLatest(agentId) {
+			const ids = agentIndex.get(agentId);
+			if (!ids || ids.size === 0) return null;
+			let latest = null;
+			for (const id of ids) {
+				const checkpoint = checkpoints.get(id);
+				if (checkpoint) {
+					if (checkpoint.expiresAt && checkpoint.expiresAt < /* @__PURE__ */ new Date()) continue;
+					if (!latest || checkpoint.createdAt > latest.createdAt) latest = checkpoint;
+				}
+			}
+			return latest ? { ...latest } : null;
+		},
+		async list(agentId, options = {}) {
+			const { limit = 100, offset = 0, before, after } = options;
+			const ids = agentIndex.get(agentId);
+			if (!ids) return [];
+			const results = [];
+			for (const id of ids) {
+				const checkpoint = checkpoints.get(id);
+				if (checkpoint) {
+					if (checkpoint.expiresAt && checkpoint.expiresAt < /* @__PURE__ */ new Date()) continue;
+					if (before && checkpoint.createdAt >= before) continue;
+					if (after && checkpoint.createdAt <= after) continue;
+					results.push({ ...checkpoint });
+				}
+			}
+			return results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()).slice(offset, offset + limit);
+		},
+		async delete(checkpointId) {
+			const checkpoint = checkpoints.get(checkpointId);
+			if (checkpoint) {
+				checkpoints.delete(checkpointId);
+				agentIndex.get(checkpoint.agentId)?.delete(checkpointId);
+			}
+		},
+		async deleteAll(agentId) {
+			const ids = agentIndex.get(agentId);
+			if (ids) {
+				for (const id of ids) checkpoints.delete(id);
+				agentIndex.delete(agentId);
+			}
+		},
+		async exists(checkpointId) {
+			return checkpoints.has(checkpointId);
+		}
+	};
+}
+/**
+* Create a Redis-backed checkpoint store
+*
+* @example
+* ```typescript
+* import { createUpstashRedis } from '../../integrations/redis';
+*
+* const redis = createUpstashRedis({ url: '...', token: '...' });
+* const store = createRedisCheckpointStore(redis, {
+*   prefix: 'agent:checkpoint:',
+*   defaultTTL: 86400 * 7, // 7 days
+* });
+* ```
+*/
+function createRedisCheckpointStore(redis, options = {}) {
+	const { prefix = "checkpoint:", defaultTTL } = options;
+	function checkpointKey(id) {
+		return `${prefix}${id}`;
+	}
+	function agentIndexKey(agentId) {
+		return `${prefix}agent:${agentId}`;
+	}
+	function serialize(checkpoint) {
+		return JSON.stringify({
+			...checkpoint,
+			createdAt: checkpoint.createdAt.toISOString(),
+			expiresAt: checkpoint.expiresAt?.toISOString(),
+			state: {
+				...checkpoint.state,
+				messages: checkpoint.state.messages.map((m) => ({
+					...m,
+					createdAt: m.createdAt.toISOString()
+				})),
+				toolCalls: checkpoint.state.toolCalls.map((t) => ({
+					...t,
+					startedAt: t.startedAt.toISOString(),
+					completedAt: t.completedAt?.toISOString()
+				}))
+			}
+		});
+	}
+	function deserialize(data) {
+		const parsed = JSON.parse(data);
+		return {
+			...parsed,
+			createdAt: new Date(parsed.createdAt),
+			expiresAt: parsed.expiresAt ? new Date(parsed.expiresAt) : void 0,
+			state: {
+				...parsed.state,
+				messages: parsed.state.messages.map((m) => ({
+					...m,
+					createdAt: new Date(m.createdAt)
+				})),
+				toolCalls: parsed.state.toolCalls.map((t) => ({
+					...t,
+					startedAt: new Date(t.startedAt),
+					completedAt: t.completedAt ? new Date(t.completedAt) : void 0
+				}))
+			}
+		};
+	}
+	return {
+		async save(checkpoint) {
+			const key = checkpointKey(checkpoint.id);
+			const ttl = checkpoint.expiresAt ? Math.floor((checkpoint.expiresAt.getTime() - Date.now()) / 1e3) : defaultTTL;
+			const setOptions = ttl && ttl > 0 ? { ex: ttl } : void 0;
+			await redis.set(key, serialize(checkpoint), setOptions);
+			await redis.zadd(agentIndexKey(checkpoint.agentId), checkpoint.createdAt.getTime(), checkpoint.id);
+		},
+		async load(checkpointId) {
+			const data = await redis.get(checkpointKey(checkpointId));
+			if (!data) return null;
+			const checkpoint = deserialize(data);
+			if (checkpoint.expiresAt && checkpoint.expiresAt < /* @__PURE__ */ new Date()) {
+				await this.delete(checkpointId);
+				return null;
+			}
+			return checkpoint;
+		},
+		async loadLatest(agentId) {
+			const ids = await redis.zrange(agentIndexKey(agentId), -1, -1);
+			if (ids.length === 0) return null;
+			const latestId = ids[0];
+			if (!latestId) return null;
+			return this.load(latestId);
+		},
+		async list(agentId, options = {}) {
+			const { limit = 100, offset = 0, before, after } = options;
+			const min = after ? after.getTime() : "-inf";
+			const max = before ? before.getTime() : "+inf";
+			const ids = await redis.zrangebyscore(agentIndexKey(agentId), min, max, { limit: {
+				offset,
+				count: limit
+			} });
+			const checkpoints = [];
+			for (const id of ids) {
+				const checkpoint = await this.load(id);
+				if (checkpoint) checkpoints.push(checkpoint);
+			}
+			return checkpoints.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+		},
+		async delete(checkpointId) {
+			const checkpoint = await this.load(checkpointId);
+			if (checkpoint) {
+				await redis.del(checkpointKey(checkpointId));
+				await redis.zrem(agentIndexKey(checkpoint.agentId), checkpointId);
+			}
+		},
+		async deleteAll(agentId) {
+			const ids = await redis.zrange(agentIndexKey(agentId), 0, -1);
+			if (ids.length > 0) await redis.del(...ids.map(checkpointKey));
+			await redis.del(agentIndexKey(agentId));
+		},
+		async exists(checkpointId) {
+			return await redis.exists(checkpointKey(checkpointId)) > 0;
+		}
+	};
+}
+/**
+* Create a checkpoint manager for an agent
+*
+* @example
+* ```typescript
+* const manager = createCheckpointManager({
+*   store: createRedisCheckpointStore(redis),
+*   autoCheckpointInterval: 5,
+*   maxCheckpointsPerAgent: 10,
+* });
+*
+* // In your agent loop
+* await manager.checkpoint(agentId, state);
+*
+* // To resume
+* const state = await manager.restore(agentId);
+* ```
+*/
+function createCheckpointManager(config) {
+	const { store, autoCheckpointInterval = 10, maxCheckpointsPerAgent = 50, version = 1, defaultTTL } = config;
+	const stepCounters = /* @__PURE__ */ new Map();
+	function generateId() {
+		return `ckpt_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+	}
+	return {
+		async checkpoint(agentId, state, options = {}) {
+			const checkpoint = {
+				id: generateId(),
+				agentId,
+				version,
+				state,
+				createdAt: /* @__PURE__ */ new Date(),
+				expiresAt: defaultTTL ? new Date(Date.now() + defaultTTL * 1e3) : void 0,
+				metadata: options.metadata
+			};
+			await store.save(checkpoint);
+			const existing = await store.list(agentId, { limit: maxCheckpointsPerAgent + 10 });
+			if (existing.length > maxCheckpointsPerAgent) {
+				const toDelete = existing.slice(maxCheckpointsPerAgent);
+				for (const old of toDelete) await store.delete(old.id);
+			}
+			return checkpoint;
+		},
+		async maybeCheckpoint(agentId, state, options) {
+			const count = (stepCounters.get(agentId) || 0) + 1;
+			stepCounters.set(agentId, count);
+			if (count % autoCheckpointInterval === 0) return this.checkpoint(agentId, state, options);
+			return null;
+		},
+		async restore(agentId) {
+			const checkpoint = await store.loadLatest(agentId);
+			if (!checkpoint) return null;
+			stepCounters.set(agentId, checkpoint.state.totalSteps);
+			return checkpoint.state;
+		},
+		async restoreFrom(checkpointId) {
+			const checkpoint = await store.load(checkpointId);
+			if (!checkpoint) return null;
+			stepCounters.set(checkpoint.agentId, checkpoint.state.totalSteps);
+			return checkpoint.state;
+		},
+		async list(agentId, options) {
+			return store.list(agentId, options);
+		},
+		async cleanup(agentId) {
+			stepCounters.delete(agentId);
+			await store.deleteAll(agentId);
+		},
+		getStore() {
+			return store;
+		}
+	};
+}
+/**
+* Create initial agent state
+*/
+function createInitialState(customState) {
+	return {
+		messages: [],
+		currentStep: 0,
+		totalSteps: 0,
+		toolCalls: [],
+		pendingApprovals: [],
+		customState: customState || {},
+		tokenUsage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		},
+		costUsd: 0,
+		status: "running"
+	};
+}
+/**
+* Merge token usage from a step
+*/
+function mergeTokenUsage(state, usage) {
+	return {
+		...state,
+		tokenUsage: {
+			promptTokens: state.tokenUsage.promptTokens + (usage.promptTokens || 0),
+			completionTokens: state.tokenUsage.completionTokens + (usage.completionTokens || 0),
+			totalTokens: state.tokenUsage.totalTokens + (usage.promptTokens || 0) + (usage.completionTokens || 0)
+		}
+	};
+}
+/**
+* Add a message to state
+*/
+function addMessage(state, message) {
+	return {
+		...state,
+		messages: [...state.messages, {
+			...message,
+			id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+			createdAt: /* @__PURE__ */ new Date()
+		}]
+	};
+}
+/**
+* Record a tool call
+*/
+function recordToolCall(state, toolCall) {
+	return {
+		...state,
+		toolCalls: [...state.toolCalls, {
+			...toolCall,
+			id: `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+			startedAt: /* @__PURE__ */ new Date()
+		}]
+	};
+}
+/**
+* Complete a tool call
+*/
+function completeToolCall(state, toolCallId, result, error) {
+	return {
+		...state,
+		toolCalls: state.toolCalls.map((tc) => tc.id === toolCallId ? {
+			...tc,
+			result,
+			error,
+			completedAt: /* @__PURE__ */ new Date()
+		} : tc)
+	};
+}
+/**
+* Update agent status
+*/
+function updateStatus(state, status, error) {
+	return {
+		...state,
+		status,
+		error
+	};
+}
+
+//#endregion
+export { AgentCheckpointSchema, AgentMessageSchema, CheckpointStateSchema, ToolCallRecordSchema, addMessage, completeToolCall, createCheckpointManager, createInitialState, createMemoryCheckpointStore, createRedisCheckpointStore, mergeTokenUsage, recordToolCall, persistence_exports as t, updateStatus };
+//# sourceMappingURL=agents-persistence.mjs.map