@absolutejs/voice 0.0.22-beta.2 → 0.0.22-beta.4

package/dist/assistant.d.ts

@@ -1,6 +1,8 @@
 import { type VoiceAgent, type VoiceAgentModel, type VoiceAgentOptions, type VoiceAgentSquadOptions, type VoiceAgentTool } from './agent';
 import { type VoiceOutcomeRecipeName, type VoiceOutcomeRecipeOptions } from './outcomeRecipes';
+import { type VoiceAssistantMemoryHandle, type VoiceAssistantMemoryOptions } from './assistantMemory';
 import type { VoiceNormalizedRouteConfig, VoiceOnTurnObjectHandler, VoiceRouteConfig, VoiceRouteResult, VoiceRuntimeOpsConfig, VoiceSessionRecord } from './types';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
 export type VoiceAssistantPreset = VoiceOutcomeRecipeName;
 export type VoiceAssistantArtifactPlan<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
@@ -11,6 +13,7 @@ export type VoiceAssistantArtifactPlan<TContext = unknown, TSession extends Voic
 };
 export type VoiceAssistantGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
     assistantId: string;
+    memory?: VoiceAssistantMemoryHandle;
 };
 export type VoiceAssistantOutputGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceAssistantGuardrailInput<TContext, TSession, TResult> & {
     result: VoiceRouteResult<TResult>;
@@ -28,6 +31,16 @@ export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSess
     tools?: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
     weight?: number;
 };
+export type VoiceAssistantMemoryLifecycleInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    assistantId: string;
+    memory: VoiceAssistantMemoryHandle;
+};
+export type VoiceAssistantMemoryLifecycle<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    afterTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult> & {
+        result: VoiceRouteResult<TResult>;
+    }) => Promise<void> | void;
+    beforeTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult>) => Promise<void> | void;
+};
 export type VoiceAssistantExperimentResolverInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
     assistantId: string;
     context: TContext;
@@ -82,6 +95,8 @@ export type VoiceAssistantOptions<TContext = unknown, TSession extends VoiceSess
     experiment?: VoiceAssistantExperiment<TContext, TSession, TResult>;
     guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
     id: string;
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
     trace?: VoiceAgentOptions<TContext, TSession, TResult>['trace'];
 };
@@ -94,6 +109,35 @@ export type VoiceAssistant<TContext = unknown, TSession extends VoiceSessionReco
         onComplete?: VoiceRouteConfig<TContext, TSession, TResult>['onComplete'];
     }) => VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
 };
+export type VoiceAssistantRunSummary = {
+    assistantId: string;
+    artifactPlans: Record<string, number>;
+    averageElapsedMs?: number;
+    blockedGuardrailCount: number;
+    escalationCount: number;
+    experiments: Record<string, number>;
+    guardrailCount: number;
+    outcomes: Record<string, number>;
+    runCount: number;
+    sessions: number;
+    toolCalls: Record<string, number>;
+    transferCount: number;
+    variants: Record<string, number>;
+    memory: {
+        deletes: number;
+        gets: number;
+        lists: number;
+        sets: number;
+    };
+};
+export type VoiceAssistantRunsSummary = {
+    assistants: VoiceAssistantRunSummary[];
+    totalRuns: number;
+};
 export declare const createVoiceExperiment: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantExperimentOptions<TContext, TSession, TResult>) => VoiceAssistantExperiment<TContext, TSession, TResult>;
 export declare const createVoiceAssistant: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantOptions<TContext, TSession, TResult>) => VoiceAssistant<TContext, TSession, TResult>;
+export declare const summarizeVoiceAssistantRuns: (input: StoredVoiceTraceEvent[] | {
+    events?: StoredVoiceTraceEvent[];
+    store?: VoiceTraceEventStore;
+}) => Promise<VoiceAssistantRunsSummary>;
 export {};

package/dist/assistantMemory.d.ts

@@ -0,0 +1,63 @@
+import type { VoiceSessionRecord } from './types';
+import type { VoiceTraceEventStore } from './trace';
+export type VoiceAssistantMemoryRecord<TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>> = {
+    assistantId: string;
+    createdAt: number;
+    key: string;
+    metadata?: TMetadata;
+    namespace: string;
+    updatedAt: number;
+    value: TValue;
+};
+export type VoiceAssistantMemoryStore<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<void>;
+    get: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<TRecord | undefined>;
+    list: (input: {
+        assistantId: string;
+        namespace?: string;
+    }) => Promise<TRecord[]>;
+    set: (input: Omit<TRecord, 'createdAt' | 'updatedAt'> & {
+        createdAt?: number;
+        updatedAt?: number;
+    }) => Promise<TRecord>;
+};
+export type VoiceAssistantMemoryNamespaceInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    assistantId: string;
+    context: TContext;
+    session: TSession;
+};
+export type VoiceAssistantMemoryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    namespace: string | ((input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<string> | string);
+    store: VoiceAssistantMemoryStore<TRecord>;
+};
+export type VoiceAssistantMemoryBinding<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+export type VoiceAssistantMemoryHandle<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (key: string) => Promise<void>;
+    get: <TValue = unknown>(key: string) => Promise<TValue | undefined>;
+    list: () => Promise<TRecord[]>;
+    namespace: string;
+    set: <TValue = unknown>(key: string, value: TValue, metadata?: Record<string, unknown>) => Promise<TRecord>;
+};
+export declare const createVoiceAssistantMemoryRecord: <TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>>(input: Omit<VoiceAssistantMemoryRecord<TValue, TMetadata>, "createdAt" | "updatedAt"> & {
+    createdAt?: number;
+    updatedAt?: number;
+}) => VoiceAssistantMemoryRecord<TValue, TMetadata>;
+export declare const createVoiceMemoryAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>() => VoiceAssistantMemoryStore<TRecord>;
+export declare const resolveVoiceAssistantMemoryNamespace: <TContext, TSession extends VoiceSessionRecord>(input: VoiceAssistantMemoryNamespaceInput<TContext, TSession> & {
+    memory: VoiceAssistantMemoryOptions<TContext, TSession>;
+}) => Promise<string>;
+export declare const createVoiceAssistantMemoryHandle: <TContext, TSession extends VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(input: {
+    assistantId: string;
+    context: TContext;
+    memory: VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+    session: TSession;
+    trace?: VoiceTraceEventStore;
+}) => Promise<VoiceAssistantMemoryHandle<TRecord>>;

package/dist/fileStore.d.ts

@@ -1,3 +1,4 @@
+import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from './assistantMemory';
 import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
 import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
 import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
@@ -6,9 +7,10 @@ export type VoiceFileStoreOptions = {
     directory: string;
     pretty?: boolean;
 };
-export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    memories: VoiceAssistantMemoryStore<TMemory>;
     reviews: VoiceCallReviewStore<TReview>;
     session: VoiceSessionStore<TSession>;
     tasks: VoiceOpsTaskStore<TTask>;
@@ -22,7 +24,8 @@ export declare const createVoiceFileIntegrationEventStore: <TEvent extends Store
 export declare const createVoiceFileExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceFileStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
 export declare const createVoiceFileTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceFileStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceFileTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;
+export declare const createVoiceFileAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceAssistantMemoryStore<TRecord>;
+export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TMemory>;
 export declare const createStoredVoiceCallReviewArtifact: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
     id: string;
 };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { voice } from './plugin';
-export { createVoiceAssistant, createVoiceExperiment } from './assistant';
+export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRuns } from './assistant';
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from './agent';
-export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
+export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
+export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { buildVoiceTraceReplay, createVoiceMemoryTraceSinkDeliveryStore, createVoiceTraceHTTPSink, createVoiceMemoryTraceEventStore, createVoiceTraceSinkDeliveryId, createVoiceTraceSinkDeliveryRecord, createVoiceTraceSinkStore, createVoiceTraceEvent, createVoiceTraceEventId, deliverVoiceTraceEventsToSinks, evaluateVoiceTrace, exportVoiceTrace, filterVoiceTraceEvents, pruneVoiceTraceEvents, redactVoiceTraceEvent, redactVoiceTraceEvents, redactVoiceTraceText, renderVoiceTraceHTML, renderVoiceTraceMarkdown, resolveVoiceTraceRedactionOptions, selectVoiceTraceEventsForPrune, summarizeVoiceTrace } from './trace';
 export { createVoiceSQLiteExternalObjectMapStore, createVoiceSQLiteIntegrationEventStore, createVoiceSQLiteReviewStore, createVoiceSQLiteRuntimeStorage, createVoiceSQLiteSessionStore, createVoiceSQLiteTaskStore, createVoiceSQLiteTraceSinkDeliveryStore, createVoiceSQLiteTraceEventStore } from './sqliteStore';
 export { createVoicePostgresExternalObjectMapStore, createVoicePostgresIntegrationEventStore, createVoicePostgresReviewStore, createVoicePostgresRuntimeStorage, createVoicePostgresSessionStore, createVoicePostgresTaskStore, createVoicePostgresTraceSinkDeliveryStore, createVoicePostgresTraceEventStore } from './postgresStore';
@@ -22,7 +23,8 @@ export { conditionAudioChunk, resolveAudioConditioningConfig } from './audioCond
 export { resolveVoiceRuntimePreset } from './presets';
 export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfiles';
 export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
-export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantVariant } from './assistant';
+export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantMemoryLifecycle, VoiceAssistantMemoryLifecycleInput, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, VoiceAssistantVariant } from './assistant';
+export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssistantMemoryOptions, VoiceAssistantMemoryRecord, VoiceAssistantMemoryStore } from './assistantMemory';
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadOptions, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';

package/dist/index.js

@@ -5594,6 +5594,112 @@ var resolveVoiceOutcomeRecipe = (name, options = {}) => {
   };
 };
 
+// src/assistantMemory.ts
+var createMemoryId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
+var createVoiceAssistantMemoryRecord = (input) => {
+  const now = Date.now();
+  return {
+    ...input,
+    createdAt: input.createdAt ?? input.updatedAt ?? now,
+    updatedAt: input.updatedAt ?? now
+  };
+};
+var createVoiceMemoryAssistantMemoryStore = () => {
+  const records = new Map;
+  return {
+    delete: async (input) => {
+      records.delete(createMemoryId(input));
+    },
+    get: async (input) => records.get(createMemoryId(input)),
+    list: async (input) => [...records.values()].filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt),
+    set: async (input) => {
+      const id = createMemoryId(input);
+      const existing = records.get(id);
+      const record = createVoiceAssistantMemoryRecord({
+        ...input,
+        createdAt: input.createdAt ?? existing?.createdAt,
+        updatedAt: input.updatedAt
+      });
+      records.set(id, record);
+      return record;
+    }
+  };
+};
+var resolveVoiceAssistantMemoryNamespace = async (input) => typeof input.memory.namespace === "function" ? await input.memory.namespace(input) : input.memory.namespace;
+var createVoiceAssistantMemoryHandle = async (input) => {
+  const namespace = await resolveVoiceAssistantMemoryNamespace({
+    assistantId: input.assistantId,
+    context: input.context,
+    memory: input.memory,
+    session: input.session
+  });
+  const trace = async (event) => {
+    await input.trace?.append({
+      at: Date.now(),
+      payload: {
+        assistantId: input.assistantId,
+        namespace,
+        ...event
+      },
+      scenarioId: input.session.scenarioId,
+      sessionId: input.session.id,
+      type: "assistant.memory"
+    });
+  };
+  return {
+    delete: async (key) => {
+      await input.memory.store.delete({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "delete",
+        key
+      });
+    },
+    get: async (key) => {
+      const record = await input.memory.store.get({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "get",
+        found: Boolean(record),
+        key
+      });
+      return record?.value;
+    },
+    list: async () => {
+      const records = await input.memory.store.list({
+        assistantId: input.assistantId,
+        namespace
+      });
+      await trace({
+        action: "list",
+        count: records.length
+      });
+      return records;
+    },
+    namespace,
+    set: async (key, value, metadata) => {
+      const record = await input.memory.store.set({
+        assistantId: input.assistantId,
+        key,
+        metadata,
+        namespace,
+        value
+      });
+      await trace({
+        action: "set",
+        key
+      });
+      return record;
+    }
+  };
+};
+
 // src/assistant.ts
 var hashString = (value) => {
   let hash = 2166136261;
@@ -5603,6 +5709,47 @@ var hashString = (value) => {
   }
   return hash >>> 0;
 };
+var increment = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+var resolveOutcome = (result) => {
+  if (result.transfer) {
+    return "transferred";
+  }
+  if (result.escalate) {
+    return "escalated";
+  }
+  if (result.voicemail) {
+    return "voicemail";
+  }
+  if (result.noAnswer) {
+    return "no-answer";
+  }
+  if (result.complete) {
+    return "completed";
+  }
+  return "continued";
+};
+var resolveArtifactPlanName = (artifactPlan) => {
+  const preset = artifactPlan?.preset;
+  if (!preset) {
+    return artifactPlan?.ops ? "custom" : undefined;
+  }
+  return typeof preset === "string" ? preset : preset.name;
+};
+var appendAssistantTrace = async (input) => {
+  await input.trace?.append({
+    at: Date.now(),
+    payload: {
+      assistantId: input.assistantId,
+      ...input.event
+    },
+    scenarioId: input.session.scenarioId,
+    sessionId: input.session.id,
+    turnId: input.turnId,
+    type: input.type
+  });
+};
 var resolvePresetOps = (artifactPlan) => {
   const preset = artifactPlan?.preset;
   if (!preset) {
@@ -5671,6 +5818,7 @@ var createVoiceExperiment = (options) => {
 };
 var createVoiceAssistant = (options) => {
   const ops = mergeOps(resolvePresetOps(options.artifactPlan), options.ops);
+  const artifactPlanName = resolveArtifactPlanName(options.artifactPlan);
   let agent;
   const baseModelOptions = "model" in options && options.model ? {
     maxToolRounds: options.maxToolRounds,
@@ -5700,14 +5848,63 @@ var createVoiceAssistant = (options) => {
     });
   }
   const onTurn = async (input) => {
+    const memory = options.memory ? await createVoiceAssistantMemoryHandle({
+      assistantId: options.id,
+      context: input.context,
+      memory: options.memory,
+      session: input.session,
+      trace: options.trace
+    }) : undefined;
     const guardrailInput = {
       ...input,
-      assistantId: options.id
+      assistantId: options.id,
+      memory
     };
+    if (memory) {
+      await options.memoryLifecycle?.beforeTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory
+      });
+    }
     const blocked = await options.guardrails?.beforeTurn?.(guardrailInput);
     if (blocked) {
+      if (memory) {
+        await options.memoryLifecycle?.afterTurn?.({
+          ...input,
+          assistantId: options.id,
+          memory,
+          result: blocked
+        });
+      }
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          action: "blocked",
+          artifactPlan: artifactPlanName,
+          outcome: resolveOutcome(blocked)
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.guardrail"
+      });
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          artifactPlan: artifactPlanName,
+          blocked: true,
+          experimentId: options.experiment?.id,
+          outcome: resolveOutcome(blocked)
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.run"
+      });
       return blocked;
     }
+    const startedAt = Date.now();
     const variant = options.experiment?.resolve({
       assistantId: options.id,
       context: input.context,
@@ -5722,12 +5919,56 @@ var createVoiceAssistant = (options) => {
       trace: options.trace,
       tools: variant.tools ?? baseModelOptions.tools
     }) : agent;
-    const result = await runner.run(input) ?? {};
+    const runResult = await runner.run(input) ?? {};
+    const result = runResult;
     const guarded = await options.guardrails?.afterTurn?.({
       ...guardrailInput,
       result
     });
-    return guarded ?? result;
+    const finalResult = guarded ?? result;
+    if (memory) {
+      await options.memoryLifecycle?.afterTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory,
+        result: finalResult
+      });
+    }
+    if (guarded) {
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          action: "rewritten",
+          artifactPlan: artifactPlanName,
+          experimentId: options.experiment?.id,
+          outcome: resolveOutcome(finalResult),
+          variantId: variant?.id
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.guardrail"
+      });
+    }
+    await appendAssistantTrace({
+      assistantId: options.id,
+      event: {
+        artifactPlan: artifactPlanName,
+        blocked: false,
+        elapsedMs: Date.now() - startedAt,
+        escalated: Boolean(finalResult.escalate),
+        experimentId: options.experiment?.id,
+        outcome: resolveOutcome(finalResult),
+        toolNames: result.toolResults?.map((tool) => tool.toolName) ?? [],
+        transferred: Boolean(finalResult.transfer),
+        variantId: variant?.id
+      },
+      session: input.session,
+      trace: options.trace,
+      turnId: input.turn.id,
+      type: "assistant.run"
+    });
+    return finalResult;
   };
   return {
     agent,
@@ -5743,6 +5984,112 @@ var createVoiceAssistant = (options) => {
     })
   };
 };
+var summarizeVoiceAssistantRuns = async (input) => {
+  const events = Array.isArray(input) ? input : input.events ?? await input.store?.list() ?? [];
+  const assistantRuns = events.filter((event) => event.type === "assistant.run");
+  const guardrails = events.filter((event) => event.type === "assistant.guardrail");
+  const byAssistant = new Map;
+  const getSummary = (assistantId) => {
+    let summary = byAssistant.get(assistantId);
+    if (!summary) {
+      summary = {
+        assistantId,
+        artifactPlans: {},
+        blockedGuardrailCount: 0,
+        elapsedCount: 0,
+        elapsedTotal: 0,
+        escalationCount: 0,
+        experiments: {},
+        guardrailCount: 0,
+        memory: {
+          deletes: 0,
+          gets: 0,
+          lists: 0,
+          sets: 0
+        },
+        outcomes: {},
+        runCount: 0,
+        sessionIds: new Set,
+        sessions: 0,
+        toolCalls: {},
+        transferCount: 0,
+        variants: {}
+      };
+      byAssistant.set(assistantId, summary);
+    }
+    return summary;
+  };
+  for (const event of assistantRuns) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    summary.runCount += 1;
+    summary.sessionIds.add(event.sessionId);
+    if (typeof event.payload.artifactPlan === "string") {
+      increment(summary.artifactPlans, event.payload.artifactPlan);
+    }
+    if (typeof event.payload.experimentId === "string") {
+      increment(summary.experiments, event.payload.experimentId);
+    }
+    if (typeof event.payload.variantId === "string") {
+      increment(summary.variants, event.payload.variantId);
+    }
+    if (typeof event.payload.outcome === "string") {
+      increment(summary.outcomes, event.payload.outcome);
+    }
+    if (event.payload.escalated === true) {
+      summary.escalationCount += 1;
+    }
+    if (event.payload.transferred === true) {
+      summary.transferCount += 1;
+    }
+    if (event.payload.blocked === true) {
+      summary.blockedGuardrailCount += 1;
+    }
+    if (typeof event.payload.elapsedMs === "number") {
+      summary.elapsedCount += 1;
+      summary.elapsedTotal += event.payload.elapsedMs;
+    }
+    if (Array.isArray(event.payload.toolNames)) {
+      for (const toolName of event.payload.toolNames) {
+        if (typeof toolName === "string") {
+          increment(summary.toolCalls, toolName);
+        }
+      }
+    }
+  }
+  for (const event of guardrails) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    summary.guardrailCount += 1;
+  }
+  for (const event of events.filter((event2) => event2.type === "assistant.memory")) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    switch (event.payload.action) {
+      case "delete":
+        summary.memory.deletes += 1;
+        break;
+      case "get":
+        summary.memory.gets += 1;
+        break;
+      case "list":
+        summary.memory.lists += 1;
+        break;
+      case "set":
+        summary.memory.sets += 1;
+        break;
+    }
+  }
+  const assistants = [...byAssistant.values()].map(({ elapsedCount, elapsedTotal, sessionIds, ...summary }) => ({
+    ...summary,
+    averageElapsedMs: elapsedCount > 0 ? Math.round(elapsedTotal / elapsedCount) : undefined,
+    sessions: sessionIds.size
+  }));
+  return {
+    assistants: assistants.sort((left, right) => left.assistantId.localeCompare(right.assistantId)),
+    totalRuns: assistantRuns.length
+  };
+};
 // src/fileStore.ts
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
 import { join } from "path";
@@ -6427,6 +6774,7 @@ var listJsonFiles = async (directory) => {
 };
 var encodeStoreId = (id) => `${encodeURIComponent(id)}.json`;
 var resolveFilePath = (directory, id) => join(directory, encodeStoreId(id));
+var createMemoryStoreId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
 var readJsonFile = async (path) => JSON.parse(await readFile(path, "utf8"));
 var writeJsonFile = async (path, value, options) => {
   await mkdir(options.directory, {
@@ -6646,6 +6994,40 @@ var createVoiceFileTraceSinkDeliveryStore = (options) => {
   };
   return { get, list, remove, set };
 };
+var createVoiceFileAssistantMemoryStore = (options) => {
+  const get = async (input) => {
+    const path = resolveFilePath(options.directory, createMemoryStoreId(input));
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async (input) => {
+    const files = await listJsonFiles(options.directory);
+    const records = await Promise.all(files.map((file) => readJsonFile(file)));
+    return records.filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt);
+  };
+  const set = async (input) => {
+    const existing = await get(input);
+    const record = createVoiceAssistantMemoryRecord({
+      ...input,
+      createdAt: input.createdAt ?? existing?.createdAt,
+      updatedAt: input.updatedAt
+    });
+    await writeJsonFile(resolveFilePath(options.directory, createMemoryStoreId(record)), record, options);
+    return record;
+  };
+  const remove = async (input) => {
+    await rm(resolveFilePath(options.directory, createMemoryStoreId(input)), {
+      force: true
+    });
+  };
+  return { delete: remove, get, list, set };
+};
 var createVoiceFileRuntimeStorage = (options) => ({
   events: createVoiceFileIntegrationEventStore({
     ...options,
@@ -6655,6 +7037,10 @@ var createVoiceFileRuntimeStorage = (options) => ({
     ...options,
     directory: join(options.directory, "external-objects")
   }),
+  memories: createVoiceFileAssistantMemoryStore({
+    ...options,
+    directory: join(options.directory, "memories")
+  }),
   reviews: createVoiceFileReviewStore({
     ...options,
     directory: join(options.directory, "reviews")
@@ -9141,6 +9527,7 @@ export {
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceAssistantRuns,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
@@ -9152,6 +9539,7 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
@@ -9227,6 +9615,7 @@ export {
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
@@ -9246,6 +9635,7 @@ export {
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
@@ -9254,6 +9644,8 @@ export {
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
+  createVoiceAssistantMemoryRecord,
+  createVoiceAssistantMemoryHandle,
   createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,

package/dist/trace.d.ts

@@ -1,4 +1,4 @@
-export type VoiceTraceEventType = 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript';
+export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.memory' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript';
 export type VoiceTraceEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     at: number;
     id?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.2",
+	"version": "0.0.22-beta.4",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",