@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.5

package/dist/assistant.d.ts

@@ -1,5 +1,6 @@
 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;
@@ -12,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>;
@@ -29,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;
@@ -83,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'];
 };
@@ -109,6 +123,12 @@ export type VoiceAssistantRunSummary = {
     toolCalls: Record<string, number>;
     transferCount: number;
     variants: Record<string, number>;
+    memory: {
+        deletes: number;
+        gets: number;
+        lists: number;
+        sets: number;
+    };
 };
 export type VoiceAssistantRunsSummary = {
     assistants: VoiceAssistantRunSummary[];

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,9 @@
 export { voice } from './plugin';
 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 { createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel } from './modelAdapters';
 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 +24,9 @@ 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, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, 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 { OpenAIVoiceAssistantModelOptions, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 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;
@@ -5742,12 +5848,35 @@ 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: {
@@ -5797,6 +5926,14 @@ var createVoiceAssistant = (options) => {
       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,
@@ -5864,6 +6001,12 @@ var summarizeVoiceAssistantRuns = async (input) => {
         escalationCount: 0,
         experiments: {},
         guardrailCount: 0,
+        memory: {
+          deletes: 0,
+          gets: 0,
+          lists: 0,
+          sets: 0
+        },
         outcomes: {},
         runCount: 0,
         sessionIds: new Set,
@@ -5919,6 +6062,24 @@ var summarizeVoiceAssistantRuns = async (input) => {
     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,
@@ -6613,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, {
@@ -6832,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,
@@ -6841,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")
@@ -6873,6 +7073,254 @@ var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectM
   sourceId: mapping.sourceId,
   sourceType: mapping.sourceType
 });
+// src/modelAdapters.ts
+var OUTPUT_SCHEMA = {
+  additionalProperties: false,
+  properties: {
+    assistantText: {
+      type: "string"
+    },
+    complete: {
+      type: "boolean"
+    },
+    escalate: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        }
+      },
+      required: ["reason"],
+      type: "object"
+    },
+    noAnswer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    },
+    result: {
+      additionalProperties: true,
+      type: "object"
+    },
+    transfer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        },
+        target: {
+          type: "string"
+        }
+      },
+      required: ["target"],
+      type: "object"
+    },
+    voicemail: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    }
+  },
+  type: "object"
+};
+var parseJSON = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {
+      assistantText: value
+    };
+  }
+};
+var normalizeRouteOutput = (output) => {
+  const result = {};
+  if (typeof output.assistantText === "string") {
+    result.assistantText = output.assistantText;
+  }
+  if (typeof output.complete === "boolean") {
+    result.complete = output.complete;
+  }
+  if (output.result !== undefined) {
+    result.result = output.result;
+  }
+  if (output.transfer && typeof output.transfer === "object") {
+    const transfer = output.transfer;
+    if (typeof transfer.target === "string") {
+      result.transfer = {
+        metadata: transfer.metadata && typeof transfer.metadata === "object" ? transfer.metadata : undefined,
+        reason: typeof transfer.reason === "string" ? transfer.reason : undefined,
+        target: transfer.target
+      };
+    }
+  }
+  if (output.escalate && typeof output.escalate === "object") {
+    const escalate = output.escalate;
+    if (typeof escalate.reason === "string") {
+      result.escalate = {
+        metadata: escalate.metadata && typeof escalate.metadata === "object" ? escalate.metadata : undefined,
+        reason: escalate.reason
+      };
+    }
+  }
+  if (output.voicemail && typeof output.voicemail === "object") {
+    const voicemail = output.voicemail;
+    result.voicemail = {
+      metadata: voicemail.metadata && typeof voicemail.metadata === "object" ? voicemail.metadata : undefined
+    };
+  }
+  if (output.noAnswer && typeof output.noAnswer === "object") {
+    const noAnswer = output.noAnswer;
+    result.noAnswer = {
+      metadata: noAnswer.metadata && typeof noAnswer.metadata === "object" ? noAnswer.metadata : undefined
+    };
+  }
+  return result;
+};
+var createJSONVoiceAssistantModel = (options) => ({
+  generate: async (input) => {
+    const output = await options.generate(input);
+    if ("assistantText" in output || "toolCalls" in output || "complete" in output || "transfer" in output || "escalate" in output) {
+      return output;
+    }
+    return options.mapOutput?.(output) ?? normalizeRouteOutput(output);
+  }
+});
+var messageToOpenAIInput = (message) => {
+  if (message.role === "tool") {
+    return {
+      call_id: message.toolCallId ?? message.name ?? crypto.randomUUID(),
+      output: message.content,
+      type: "function_call_output"
+    };
+  }
+  return {
+    content: message.content,
+    role: message.role === "system" ? "developer" : message.role
+  };
+};
+var extractText = (response) => {
+  if (typeof response.output_text === "string") {
+    return response.output_text;
+  }
+  const output = Array.isArray(response.output) ? response.output : [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    const content = Array.isArray(record.content) ? record.content : [];
+    for (const contentItem of content) {
+      if (!contentItem || typeof contentItem !== "object") {
+        continue;
+      }
+      const contentRecord = contentItem;
+      if (typeof contentRecord.text === "string") {
+        return contentRecord.text;
+      }
+    }
+  }
+  return "";
+};
+var extractToolCalls = (response) => {
+  const output = Array.isArray(response.output) ? response.output : [];
+  const toolCalls = [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "function_call" || typeof record.name !== "string") {
+      continue;
+    }
+    const args = typeof record.arguments === "string" ? parseJSON(record.arguments) : {};
+    toolCalls.push({
+      args,
+      id: typeof record.call_id === "string" ? record.call_id : typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createOpenAIVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  const model = options.model ?? "gpt-4.1-mini";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
+        body: JSON.stringify({
+          input: input.messages.map(messageToOpenAIInput),
+          instructions: [
+            input.system,
+            "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools."
+          ].filter(Boolean).join(`
+
+`),
+          max_output_tokens: options.maxOutputTokens,
+          model,
+          temperature: options.temperature,
+          text: {
+            format: {
+              name: "voice_route_result",
+              schema: OUTPUT_SCHEMA,
+              strict: false,
+              type: "json_schema"
+            }
+          },
+          tool_choice: input.tools.length ? "auto" : "none",
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            name: tool.name,
+            parameters: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            strict: false,
+            type: "function"
+          }))
+        }),
+        headers: {
+          authorization: `Bearer ${options.apiKey}`,
+          "content-type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(`OpenAI voice assistant model failed: HTTP ${response.status}`);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractText(body)));
+    }
+  };
+};
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -9339,6 +9787,7 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
@@ -9414,6 +9863,7 @@ export {
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
@@ -9433,6 +9883,7 @@ export {
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
@@ -9441,6 +9892,8 @@ export {
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
+  createVoiceAssistantMemoryRecord,
+  createVoiceAssistantMemoryHandle,
   createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,
@@ -9453,6 +9906,8 @@ export {
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceAssistantModel,
+  createJSONVoiceAssistantModel,
   createId,
   createDomainPhraseHints,
   createDomainLexicon,

package/dist/modelAdapters.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput } from './agent';
+import type { VoiceSessionRecord } from './types';
+export type VoiceJSONAssistantModelHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: VoiceAgentModelInput<TContext, TSession>) => Promise<Record<string, unknown> | VoiceAgentModelOutput<TResult>> | Record<string, unknown> | VoiceAgentModelOutput<TResult>;
+export type VoiceJSONAssistantModelOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    generate: VoiceJSONAssistantModelHandler<TContext, TSession, TResult>;
+    mapOutput?: (output: Record<string, unknown>) => VoiceAgentModelOutput<TResult>;
+};
+export type OpenAIVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+};
+export declare const createJSONVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceJSONAssistantModelOptions<TContext, TSession, TResult>) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createOpenAIVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: OpenAIVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;

package/dist/trace.d.ts

@@ -1,4 +1,4 @@
-export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.run' | '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.3",
+	"version": "0.0.22-beta.5",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",