@mastra/memory 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/processors/observational-memory/reflector-runner.d.ts

@@ -0,0 +1,133 @@
+import type { MessageList } from '@mastra/core/agent';
+import type { Mastra } from '@mastra/core/mastra';
+import type { ObservabilityContext } from '@mastra/core/observability';
+import type { ProcessorContext, ProcessorStreamWriter } from '@mastra/core/processors';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { MemoryStorage, ObservationalMemoryRecord } from '@mastra/core/storage';
+import type { ProviderMetadata } from '@mastra/core/stream';
+import type { Memory } from '../../index.js';
+import { BufferingCoordinator } from './buffering-coordinator.js';
+import type { ModelByInputTokens } from './model-by-input-tokens.js';
+import type { CompressionLevel } from './reflector-agent.js';
+import type { TokenCounter } from './token-counter.js';
+import type { ObservationDebugEvent, ObservationModelContext, ObserveHooks, ResolvedObservationConfig, ResolvedReflectionConfig } from './types.js';
+type ConcreteReflectionModel = Exclude<ResolvedReflectionConfig['model'], ModelByInputTokens>;
+type ReflectionModelResolver = (inputTokens: number) => {
+    model: ConcreteReflectionModel;
+    selectedThreshold?: number;
+    routingStrategy?: 'model-by-input-tokens';
+    routingThresholds?: string;
+};
+/**
+ * Runs the Reflector agent for compressing observations.
+ * Handles synchronous reflection, async buffered reflection, and activation.
+ */
+export declare class ReflectorRunner {
+    private readonly reflectionConfig;
+    private readonly observationConfig;
+    private readonly tokenCounter;
+    private readonly resolveModel;
+    private readonly storage;
+    private readonly scope;
+    private readonly buffering;
+    private readonly emitDebugEvent;
+    private readonly persistMarkerToStorage;
+    private readonly persistMarkerToMessage;
+    private readonly getCompressionStartLevel;
+    private readonly memory?;
+    private mastra?;
+    constructor(opts: {
+        reflectionConfig: ResolvedReflectionConfig;
+        observationConfig: ResolvedObservationConfig;
+        tokenCounter: TokenCounter;
+        storage: MemoryStorage;
+        scope: 'thread' | 'resource';
+        buffering: BufferingCoordinator;
+        emitDebugEvent: (event: ObservationDebugEvent) => void;
+        persistMarkerToStorage: (marker: {
+            type: string;
+            data: unknown;
+        }, threadId: string, resourceId?: string) => Promise<void>;
+        persistMarkerToMessage: (marker: {
+            type: string;
+            data: unknown;
+        }, messageList: MessageList | undefined, threadId: string, resourceId?: string) => Promise<void>;
+        getCompressionStartLevel: (requestContext?: RequestContext) => Promise<CompressionLevel>;
+        resolveModel: ReflectionModelResolver;
+        mastra?: Mastra;
+        memory?: Memory;
+    });
+    __registerMastra(mastra: Mastra): void;
+    private createAgent;
+    private getObservationMarkerConfig;
+    /**
+     * Resolve the effective reflection observationTokens for a record.
+     * Only explicit per-record overrides (stored under `_overrides`) win;
+     * the initial config snapshot is ignored so instance-level changes
+     * still take effect for existing records.
+     */
+    private getEffectiveReflectionTokens;
+    /**
+     * Call the Reflector agent with escalating compression levels.
+     */
+    call(observations: string, manualPrompt?: string, streamContext?: {
+        writer?: ProcessorStreamWriter;
+        cycleId: string;
+        startedAt: string;
+        recordId: string;
+        threadId: string;
+        resourceId?: string;
+    }, observationTokensThreshold?: number, abortSignal?: AbortSignal, skipContinuationHints?: boolean, compressionStartLevel?: CompressionLevel, requestContext?: RequestContext, priorExtractedValues?: Record<string, unknown>, observabilityContext?: ObservabilityContext, model?: ConcreteReflectionModel, mainAgent?: ProcessorContext['agent'], sendSignal?: ProcessorContext['sendSignal']): Promise<{
+        observations: string;
+        suggestedContinuation?: string;
+        extractedValues?: Record<string, unknown>;
+        extractionFailures?: Array<{
+            slug: string;
+            error: string;
+        }>;
+        usage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+            totalTokens?: number;
+        };
+        providerMetadata?: ProviderMetadata;
+    }>;
+    /**
+     * Start an async buffered reflection in the background.
+     */
+    private startAsyncBufferedReflection;
+    /**
+     * Perform async buffered reflection — reflects observations and stores to bufferedReflection.
+     * Does NOT create a new generation or update activeObservations.
+     */
+    private doAsyncBufferedReflection;
+    /**
+     * Try to activate buffered reflection when threshold is reached.
+     * Returns a discriminated result so the caller can distinguish between
+     * "activated", "no buffer present", and "suppressed by overshoot guard"
+     * without re-deriving that state.
+     */
+    private tryActivateBufferedReflection;
+    /**
+     * Check if reflection needed and trigger if so.
+     * Supports both synchronous reflection and async buffered reflection.
+     * @internal Used by observation strategies. Do not call directly.
+     */
+    maybeReflect(opts: {
+        record: ObservationalMemoryRecord;
+        observationTokens: number;
+        threadId?: string;
+        writer?: ProcessorStreamWriter;
+        abortSignal?: AbortSignal;
+        mainAgent?: ProcessorContext['agent'];
+        sendSignal?: ProcessorContext['sendSignal'];
+        messageList?: MessageList;
+        currentModel?: ObservationModelContext;
+        reflectionHooks?: Pick<ObserveHooks, 'onReflectionStart' | 'onReflectionEnd'>;
+        requestContext?: RequestContext;
+        observabilityContext?: ObservabilityContext;
+        lastActivityAt?: number;
+    }): Promise<void>;
+}
+export {};
+//# sourceMappingURL=reflector-runner.d.ts.map

package/dist/processors/observational-memory/reflector-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflector-runner.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/reflector-runner.ts"],"names":[],"mappings":"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"}

package/dist/processors/observational-memory/repro-capture.d.ts

@@ -0,0 +1,33 @@
+import type { MastraDBMessage, MessageList } from '@mastra/core/agent';
+import type { ProcessInputStepArgs } from '@mastra/core/processors';
+import type { BufferedObservationChunk, ObservationalMemoryRecord } from '@mastra/core/storage';
+import type { ObserverExchange } from './observer-runner.js';
+export declare function isOmReproCaptureEnabled(): boolean;
+export declare function safeCaptureJson(value: unknown): unknown;
+export declare function writeObserverExchangeReproCapture(params: {
+    threadId: string;
+    resourceId?: string;
+    label: string;
+    observerExchange?: ObserverExchange;
+    details?: Record<string, unknown>;
+    debug?: (message: string) => void;
+}): void;
+export declare function writeProcessInputStepReproCapture(params: {
+    threadId: string;
+    resourceId?: string;
+    stepNumber: number;
+    args: ProcessInputStepArgs;
+    preRecord: ObservationalMemoryRecord;
+    postRecord: ObservationalMemoryRecord;
+    preMessages: MastraDBMessage[];
+    preBufferedChunks: BufferedObservationChunk[];
+    preContextTokenCount: number;
+    preSerializedMessageList: ReturnType<MessageList['serialize']>;
+    postBufferedChunks: BufferedObservationChunk[];
+    postContextTokenCount: number;
+    messageList: MessageList;
+    details: Record<string, unknown>;
+    observerExchange?: ObserverExchange;
+    debug?: (message: string) => void;
+}): void;
+//# sourceMappingURL=repro-capture.d.ts.map

package/dist/processors/observational-memory/repro-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repro-capture.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/repro-capture.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEhG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAc1D,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYvD;AAqND,wBAAgB,iCAAiC,CAAC,MAAM,EAAE;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,QAwDA;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,SAAS,EAAE,yBAAyB,CAAC;IACrC,UAAU,EAAE,yBAAyB,CAAC;IACtC,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,iBAAiB,EAAE,wBAAwB,EAAE,CAAC;IAC9C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wBAAwB,EAAE,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;IAC/D,kBAAkB,EAAE,wBAAwB,EAAE,CAAC;IAC/C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,QA2HA"}

package/dist/processors/observational-memory/retry.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Retry knobs for the internal OM transport-error retry wrapper.
+ * Exported as a mutable object so tests can shrink the backoff schedule
+ * without changing public API.
+ *
+ * With the defaults the per-retry pre-jitter backoff schedule is:
+ *   1s, 2s, 4s, 8s, 16s, 32s, 64s, 120s (cap)
+ * giving 8 retries / 9 total attempts and ~247s (~4 minutes) of waiting
+ * before the final attempt fails. Designed to ride out short provider /
+ * network blips without holding the actor turn for much longer than that.
+ *
+ * @internal
+ */
+export declare const RETRY_CONFIG: {
+    /** Maximum number of retry *attempts* (total tries = maxRetries + 1). */
+    maxRetries: number;
+    /** Initial backoff delay in milliseconds. */
+    initialDelayMs: number;
+    /** Multiplier applied to the delay after each failed attempt. */
+    backoffFactor: number;
+    /** Cap on per-attempt delay (ms). */
+    maxDelayMs: number;
+    /** Random jitter as a fraction of the computed delay (e.g. 0.2 = ±20%). */
+    jitter: number;
+};
+/**
+ * Returns true when the given error looks like a transient transport-class
+ * failure that's worth retrying — undici `terminated`, `fetch failed`,
+ * `UND_ERR_*` codes, AI SDK `APICallError` with `isRetryable: true`, and
+ * common HTTP 408/425/429/5xx statuses. Walks the `error.cause` chain so
+ * wrapper errors don't hide the real failure.
+ *
+ * Never retries on user-initiated aborts.
+ *
+ * @internal
+ */
+export declare function isTransientLLMError(error: unknown): boolean;
+/**
+ * Compute the backoff delay (ms) for the Nth retry (0-indexed).
+ *
+ * Exponential growth (`initialDelayMs * backoffFactor^attempt`) capped at
+ * `maxDelayMs`, then nudged by ±`jitter` (fractional). Exported for unit
+ * tests that lock the schedule against drift.
+ *
+ * @internal
+ */
+export declare function computeDelay(attempt: number): number;
+export interface WithRetryOptions {
+    /** Short label used in debug logs (e.g. 'observer', 'reflector'). */
+    label: string;
+    /** Optional abort signal — cancels both in-flight attempts and backoff waits. */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Run `fn` with retries on transient transport-class errors.
+ *
+ * Non-transient errors (auth, validation, schema, etc.) are rethrown
+ * immediately. User-initiated aborts are rethrown without delay.
+ *
+ * @internal
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, opts: WithRetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/processors/observational-memory/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/retry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;IACvB,yEAAyE;;IAEzE,6CAA6C;;IAE7C,iEAAiE;;IAEjE,qCAAqC;;IAErC,2EAA2E;;CAE5E,CAAC;AAyDF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAyB3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQpD;AAsBD,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,CAgC3F"}

package/dist/processors/observational-memory/string-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Slice a string up to `end` UTF-16 code units without splitting a surrogate
+ * pair. If `end` would land immediately after a lone high surrogate
+ * (U+D800..U+DBFF), the slice backs off by one code unit so the pair is
+ * dropped as a whole.
+ *
+ * Lone UTF-16 surrogates are rejected by strict JSON parsers (e.g. Anthropic's
+ * with `no low surrogate in string`), so any truncation of observer-facing
+ * text that could cut an emoji/astral codepoint in half must go through this
+ * helper.
+ */
+export declare function safeSlice(str: string, end: number): string;
+//# sourceMappingURL=string-utils.d.ts.map

package/dist/processors/observational-memory/string-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/string-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM1D"}

package/dist/processors/observational-memory/summarize.d.ts

@@ -0,0 +1,92 @@
+import type { MastraDBMessage } from '@mastra/core/agent';
+import type { Mastra } from '@mastra/core/mastra';
+import type { ObservabilityContext } from '@mastra/core/observability';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { Memory } from '../../index.js';
+import type { ExtractionFailure } from './extracted-values.js';
+import type { Extractor } from './extractor.js';
+import type { ModelByInputTokens } from './model-by-input-tokens.js';
+import type { ObservationalMemoryModel } from './types.js';
+/** A concrete model config — token-based model routing is not supported for one-shot summarization. */
+export type SummarizeModel = Exclude<ObservationalMemoryModel, ModelByInputTokens>;
+/** Defaults for how `Memory.summarizeThread()` loads a thread's messages from storage. */
+export declare const SUMMARIZE_THREAD_DEFAULTS: {
+    /** Stop loading older messages once the collected messages exceed this estimated token count. */
+    readonly maxInputTokens: 1000000;
+    /** Number of messages fetched per storage page while paginating backwards from the newest message. */
+    readonly pageSize: 100;
+};
+export interface SummarizeConversationOptions {
+    /** Model that runs the summarization (e.g. a router string like `'openai/gpt-4.1-mini'`). */
+    model: SummarizeModel;
+    /** The conversation to summarize. */
+    messages: MastraDBMessage[];
+    /** Extra guidance appended to the summarizer's system prompt (e.g. what to focus on, audience). */
+    instructions?: string;
+    /** Extractors to run over the conversation. Structured (with a schema) or inline. `onExtracted` hooks fire. */
+    extract?: Extractor<any>[];
+    /** Thread the conversation belongs to. Defaults to the first `threadId` found on `messages`. Passed to extractor contexts. */
+    threadId?: string;
+    /** Resource (user) the conversation belongs to. Defaults to the first `resourceId` found on `messages`. Passed to extractor contexts. */
+    resourceId?: string;
+    requestContext?: RequestContext;
+    observabilityContext?: ObservabilityContext;
+    abortSignal?: AbortSignal;
+    /** Memory instance forwarded to extractor contexts (set automatically by `Memory.summarizeThread()`). */
+    memory?: Memory;
+    /** Mastra instance for custom gateway model resolution (set automatically by `Memory.summarizeThread()`). */
+    mastra?: Mastra;
+}
+export interface SummarizeConversationResult {
+    /** The distilled observations produced from the conversation (dense bullet form). */
+    summary: string;
+    /** Values produced by `extract` extractors, keyed by extractor slug (after `onExtracted` hooks ran). */
+    extracted: Record<string, unknown>;
+    /** Extractors that failed to produce a valid value, with the reason. */
+    extractionFailures?: ExtractionFailure[];
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+}
+/**
+ * Summarize a conversation in one shot, without Observational Memory attached to an agent.
+ *
+ * Reuses Observational Memory's Observer plumbing — the same distillation prompt, output
+ * parsing, retry handling, and extractor pipeline — as a standalone call over the messages
+ * you pass in. Nothing is read from or written to storage: the summary and extracted values
+ * are returned to you (and to each extractor's `onExtracted` hook), so you decide where they
+ * go.
+ *
+ * Use this when a session ends and you want a summary or structured extraction of the whole
+ * conversation — for example a voice call at hang-up. If Observational Memory is configured
+ * on a `Memory` instance and you want to summarize one of its threads, use
+ * `memory.summarizeThread()` instead, which loads the messages for you.
+ *
+ * @example
+ * ```ts
+ * import { summarizeConversation, Extractor } from '@mastra/memory';
+ * import { z } from 'zod';
+ *
+ * const result = await summarizeConversation({
+ *   model: 'openai/gpt-4.1-mini',
+ *   messages,
+ *   instructions: 'Summarize this voicemail call for the business owner.',
+ *   extract: [
+ *     new Extractor({
+ *       name: 'call-summary',
+ *       instructions: 'Return a concise summary of the call.',
+ *       schema: z.object({
+ *         summary: z.string(),
+ *         sentiment: z.enum(['positive', 'neutral', 'negative']),
+ *       }),
+ *       metadataKeyPath: false,
+ *     }),
+ *   ],
+ * });
+ * result.extracted['call-summary']; // { summary, sentiment }
+ * ```
+ */
+export declare function summarizeConversation(opts: SummarizeConversationOptions): Promise<SummarizeConversationResult>;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/processors/observational-memory/summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/summarize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAGpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,OAAO,KAAK,EAAE,wBAAwB,EAA6B,MAAM,SAAS,CAAC;AAEnF,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,wBAAwB,EAAE,kBAAkB,CAAC,CAAC;AAEnF,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB;IACpC,iGAAiG;;IAEjG,sGAAsG;;CAE9F,CAAC;AAEX,MAAM,WAAW,4BAA4B;IAC3C,6FAA6F;IAC7F,KAAK,EAAE,cAAc,CAAC;IACtB,qCAAqC;IACrC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,mGAAmG;IACnG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+GAA+G;IAC/G,OAAO,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,8HAA8H;IAC9H,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yIAAyI;IACzI,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6GAA6G;IAC7G,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,2BAA2B;IAC1C,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAC;IAChB,wGAAwG;IACxG,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACzC,KAAK,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAyDpH"}

package/dist/processors/observational-memory/temporal-markers.d.ts

@@ -0,0 +1,4 @@
+import type { ProcessInputStepArgs } from '@mastra/core/processors';
+export declare const TEMPORAL_GAP_REMINDER_TYPE = "temporal-gap";
+export declare function insertTemporalGapMarkers({ messageList, sendSignal, }: Pick<ProcessInputStepArgs, 'messageList' | 'sendSignal'>): Promise<void>;
+//# sourceMappingURL=temporal-markers.d.ts.map

package/dist/processors/observational-memory/temporal-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-markers.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/temporal-markers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAKpE,eAAO,MAAM,0BAA0B,iBAAiB,CAAC;AA6DzD,wBAAsB,wBAAwB,CAAC,EAC7C,WAAW,EACX,UAAU,GACX,EAAE,IAAI,CAAC,oBAAoB,EAAE,aAAa,GAAG,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD1E"}

package/dist/processors/observational-memory/temporary-memory.d.ts

@@ -0,0 +1,8 @@
+import type { AgentMemoryOption } from '@mastra/core/agent';
+import type { MastraMemory } from '@mastra/core/memory';
+export interface TemporaryOmMemoryContext {
+    memory: MastraMemory;
+    options: AgentMemoryOption;
+}
+export declare function createTemporaryOmMemoryContext(prefix: string): TemporaryOmMemoryContext;
+//# sourceMappingURL=temporary-memory.d.ts.map

package/dist/processors/observational-memory/temporary-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporary-memory.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/temporary-memory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAmBvF"}

package/dist/processors/observational-memory/thresholds.d.ts

@@ -0,0 +1,52 @@
+import type { BufferedObservationChunk } from '@mastra/core/storage';
+import type { ThresholdRange } from './types.js';
+/**
+ * Get the maximum value from a threshold (simple number or range).
+ */
+export declare function getMaxThreshold(threshold: number | ThresholdRange): number;
+/**
+ * Calculate dynamic threshold based on observation space.
+ * When shareTokenBudget is enabled, the message threshold can expand
+ * into unused observation space, up to the total context budget.
+ *
+ * Total budget = messageTokens + observationTokens
+ * Effective threshold = totalBudget - currentObservationTokens
+ *
+ * Example with 30k:40k thresholds (70k total):
+ * - 0 observations → messages can use ~70k
+ * - 10k observations → messages can use ~60k
+ * - 40k observations → messages back to ~30k
+ */
+export declare function calculateDynamicThreshold(threshold: number | ThresholdRange, currentObservationTokens: number): number;
+/**
+ * Resolve bufferTokens config value.
+ * Values in (0, 1) are treated as ratios of the message threshold.
+ * e.g. bufferTokens: 0.25 with messageTokens: 20_000 → 5_000
+ */
+export declare function resolveBufferTokens(bufferTokens: number | false | undefined, messageTokens: number | ThresholdRange): number | undefined;
+/**
+ * Resolve blockAfter config value.
+ * Values in [1, 100) are treated as multipliers of the threshold.
+ * e.g. blockAfter: 1.5 with messageTokens: 20_000 → 30_000
+ * Values >= 100 are treated as absolute token counts.
+ * Defaults to 1.2 (120% of threshold) when async buffering is enabled but blockAfter is omitted.
+ */
+export declare function resolveBlockAfter(blockAfter: number | undefined, messageTokens: number | ThresholdRange): number | undefined;
+/**
+ * Convert bufferActivation to an absolute retention floor (tokens to keep after activation).
+ * When bufferActivation >= 1000, it's an absolute retention target.
+ * Otherwise it's a ratio: retentionFloor = threshold * (1 - ratio).
+ */
+export declare function resolveRetentionFloor(bufferActivation: number, messageTokensThreshold: number): number;
+/**
+ * Convert bufferActivation to the equivalent ratio (0-1) for the storage layer.
+ * When bufferActivation >= 1000, it's an absolute retention target, so we compute
+ * the equivalent ratio: 1 - (bufferActivation / threshold).
+ */
+export declare function resolveActivationRatio(bufferActivation: number, messageTokensThreshold: number): number;
+/**
+ * Calculate the projected message tokens that would be removed if activation happened now.
+ * This replicates the chunk boundary logic in swapBufferedToActive without actually activating.
+ */
+export declare function calculateProjectedMessageRemoval(chunks: BufferedObservationChunk[], bufferActivation: number, messageTokensThreshold: number, currentPendingTokens: number): number;
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/processors/observational-memory/thresholds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thresholds.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/thresholds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,MAAM,CAK1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,GAAG,cAAc,EAClC,wBAAwB,EAAE,MAAM,GAC/B,MAAM,CAiBR;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,EACxC,aAAa,EAAE,MAAM,GAAG,cAAc,GACrC,MAAM,GAAG,SAAS,CAOpB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,EAAE,MAAM,GAAG,cAAc,GACrC,MAAM,GAAG,SAAS,CASpB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,GAAG,MAAM,CAItG;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,GAAG,MAAM,CAKvG;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,wBAAwB,EAAE,EAClC,gBAAgB,EAAE,MAAM,EACxB,sBAAsB,EAAE,MAAM,EAC9B,oBAAoB,EAAE,MAAM,GAC3B,MAAM,CAkER"}

package/dist/processors/observational-memory/token-counter.d.ts

@@ -0,0 +1,57 @@
+import type { MastraDBMessage } from '@mastra/core/agent';
+export type TokenCounterModelContext = {
+    provider?: string;
+    modelId?: string;
+};
+type TokenCounterOptions = {
+    model?: string | TokenCounterModelContext;
+};
+/**
+ * Token counting utility using tokenx for rough local estimation and
+ * provider-aware heuristics for image parts so multimodal prompts are not
+ * undercounted as generic JSON blobs.
+ */
+export declare class TokenCounter {
+    private readonly cacheSource;
+    private readonly defaultModelContext?;
+    private readonly modelContextStorage;
+    private readonly inFlightAttachmentCounts;
+    private static readonly TOKENS_PER_MESSAGE;
+    private static readonly TOKENS_PER_CONVERSATION;
+    constructor(options?: TokenCounterOptions);
+    runWithModelContext<T>(model: string | TokenCounterModelContext | undefined, fn: () => T): T;
+    private getModelContext;
+    /**
+     * Count tokens in a plain string
+     */
+    countString(text: string): number;
+    private readOrPersistPartEstimate;
+    private readOrPersistFixedPartEstimate;
+    private readOrPersistMessageEstimate;
+    private resolveToolResultForTokenCounting;
+    private countMultimodalToolResultContent;
+    private estimateImageAssetTokens;
+    private estimateImageTokens;
+    private estimateImageLikeFileTokens;
+    private countAttachmentPartSync;
+    private buildRemoteAttachmentCachePayload;
+    private fetchProviderAttachmentTokenEstimate;
+    private countAttachmentPartAsync;
+    private countNonAttachmentPart;
+    /**
+     * Count tokens in a single message
+     */
+    countMessage(message: MastraDBMessage): number;
+    countMessageAsync(message: MastraDBMessage): Promise<number>;
+    /**
+     * Count tokens in an array of messages
+     */
+    countMessages(messages: MastraDBMessage[]): number;
+    countMessagesAsync(messages: MastraDBMessage[]): Promise<number>;
+    /**
+     * Count tokens in observations string
+     */
+    countObservations(observations: string): number;
+}
+export {};
+//# sourceMappingURL=token-counter.d.ts.map

package/dist/processors/observational-memory/token-counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-counter.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/token-counter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAa1D,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,wBAAwB,CAAC;CAC3C,CAAC;AAsqCF;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAA2B;IAChE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAiE;IACrG,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAkD;IAI3F,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IAEjD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAM;gBAEzC,OAAO,CAAC,EAAE,mBAAmB;IAKzC,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAI5F,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAKjC,OAAO,CAAC,yBAAyB;IAkBjC,OAAO,CAAC,8BAA8B;IAiBtC,OAAO,CAAC,4BAA4B;IAkBpC,OAAO,CAAC,iCAAiC;IAOzC,OAAO,CAAC,gCAAgC;IAkIxC,OAAO,CAAC,wBAAwB;IAsEhC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,uBAAuB;IAkC/B,OAAO,CAAC,iCAAiC;YAiC3B,oCAAoC;YAyBpC,wBAAwB;IAyFtC,OAAO,CAAC,sBAAsB;IAsG9B;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM;IAiCxC,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAiClE;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,MAAM;IAU5C,kBAAkB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAOtE;;OAEG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;CAGhD"}

package/dist/processors/observational-memory/tool-result-helpers.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS = 10000;
+export declare function resolveToolResultValue(part: {
+    providerMetadata?: Record<string, any>;
+} | undefined, invocationResult: unknown): {
+    value: unknown;
+    usingStoredModelOutput: boolean;
+};
+export declare function truncateStringByTokens(text: string, maxTokens: number): string;
+export declare function formatToolResultForObserver(value: unknown, options?: {
+    maxTokens?: number;
+}): string;
+//# sourceMappingURL=tool-result-helpers.d.ts.map

package/dist/processors/observational-memory/tool-result-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-helpers.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/tool-result-helpers.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,uCAAuC,QAAS,CAAC;AAwD9D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,GAAG,SAAS,EAC5D,gBAAgB,EAAE,OAAO,GACxB;IACD,KAAK,EAAE,OAAO,CAAC;IACf,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAaA;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAiC9E;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACA,MAAM,CAIR"}

package/dist/processors/observational-memory/tracing.d.ts

@@ -0,0 +1,17 @@
+import type { ObservabilityContext } from '@mastra/core/observability';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { ModelByInputTokens } from './model-by-input-tokens.js';
+import type { ResolvedObservationConfig, ResolvedReflectionConfig } from './types.js';
+type OmTracingModel = Exclude<ResolvedObservationConfig['model'] | ResolvedReflectionConfig['model'], ModelByInputTokens>;
+type OmTracingPhase = 'observer' | 'observer-multi-thread' | 'reflector';
+export declare function withOmTracingSpan<T>({ phase, model, inputTokens, requestContext, observabilityContext, metadata, callback, }: {
+    phase: OmTracingPhase;
+    model: OmTracingModel;
+    inputTokens: number;
+    requestContext?: RequestContext;
+    observabilityContext?: ObservabilityContext;
+    metadata?: Record<string, unknown>;
+    callback: (observabilityContext: ObservabilityContext) => Promise<T>;
+}): Promise<T>;
+export {};
+//# sourceMappingURL=tracing.d.ts.map

package/dist/processors/observational-memory/tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/tracing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAEnF,KAAK,cAAc,GAAG,OAAO,CAC3B,yBAAyB,CAAC,OAAO,CAAC,GAAG,wBAAwB,CAAC,OAAO,CAAC,EACtE,kBAAkB,CACnB,CAAC;AAEF,KAAK,cAAc,GAAG,UAAU,GAAG,uBAAuB,GAAG,WAAW,CAAC;AAuBzE,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,EACzC,KAAK,EACL,KAAK,EACL,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,cAAc,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,QAAQ,EAAE,CAAC,oBAAoB,EAAE,oBAAoB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACtE,GAAG,OAAO,CAAC,CAAC,CAAC,CAuBb"}