mastra-ai
diff --git a/‎.changeset/brave-caches-observe.md‎
Lines changed: 20 additions & 0 deletions b/‎.changeset/brave-caches-observe.md‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎.changeset/quiet-walls-rest.md‎
Lines changed: 7 additions & 0 deletions b/‎.changeset/quiet-walls-rest.md‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎docs/src/content/en/docs/memory/observational-memory.mdx‎
Lines changed: 19 additions & 6 deletions b/‎docs/src/content/en/docs/memory/observational-memory.mdx‎
Lines changed: 19 additions & 6 deletions
diff --git a/‎docs/src/content/en/reference/memory/observational-memory.mdx‎
Lines changed: 6 additions & 6 deletions b/‎docs/src/content/en/reference/memory/observational-memory.mdx‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎mastracode/src/agents/memory.ts‎
Lines changed: 1 addition & 1 deletion b/‎mastracode/src/agents/memory.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎mastracode/src/tui/components/__tests__/idle-counter.test.ts‎
Lines changed: 35 additions & 0 deletions b/‎mastracode/src/tui/components/__tests__/idle-counter.test.ts‎
Lines changed: 35 additions & 0 deletions
diff --git a/‎mastracode/src/tui/components/__tests__/om-marker.test.ts‎
Lines changed: 14 additions & 0 deletions b/‎mastracode/src/tui/components/__tests__/om-marker.test.ts‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎mastracode/src/tui/components/idle-counter.ts‎
Lines changed: 81 additions & 0 deletions b/‎mastracode/src/tui/components/idle-counter.ts‎
Lines changed: 81 additions & 0 deletions
diff --git a/‎mastracode/src/tui/components/om-marker.ts‎
Lines changed: 4 additions & 1 deletion b/‎mastracode/src/tui/components/om-marker.ts‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎mastracode/src/tui/handlers/__tests__/om.test.ts‎
Lines changed: 41 additions & 0 deletions b/‎mastracode/src/tui/handlers/__tests__/om.test.ts‎
Lines changed: 41 additions & 0 deletions
@@ -0,0 +1,20 @@
+---
+'@mastra/core': minor
+'@mastra/memory': minor
+---
+
+Added `activateAfterIdle: "auto"` for Observational Memory early activation.
+
+Mastra can now choose an idle activation timeout from the active model provider's prompt cache behavior. OpenAI also respects `providerOptions.openai.promptCacheRetention` when available.
+
+```ts
+const memory = new Memory({
+  options: {
+    observationalMemory: {
+      model: 'google/gemini-2.5-flash',
+      activateAfterIdle: 'auto',
+      activateOnProviderChange: true,
+    },
+  },
+})
+```
@@ -0,0 +1,7 @@
+---
+'mastracode': patch
+---
+
+Updated MastraCode to use provider-aware Observational Memory idle activation.
+
+MastraCode now sets `activateAfterIdle: "auto"`, shows an idle-time counter above the input after one minute of inactivity, and combines back-to-back OM activation markers into a single line.
@@ -104,7 +104,7 @@ const memory = new Memory({
   options: {
     observationalMemory: {
       model: 'google/gemini-2.5-flash',
-      activateAfterIdle: '5m',
+      activateAfterIdle: 'auto',
       activateOnProviderChange: true,
     },
   },
@@ -495,30 +495,43 @@ Reflection works similarly — the Reflector runs in the background when observa
 | `observation.bufferTokens` | `0.2` | How often to buffer. `0.2` means every 20% of `messageTokens` — with the default 30k threshold, that's roughly every 6k tokens. Can also be an absolute token count (e.g. `5000`). |
 | `observation.bufferActivation` | `0.8` | How aggressively to clear the message window on activation. `0.8` means remove enough messages to keep only 20% of `messageTokens` remaining. Lower values keep more message history. |
 | `observation.blockAfter` | `1.2` | Safety threshold as a multiplier of `messageTokens`. At `1.2`, synchronous observation is forced at 36k tokens (1.2 × 30k). Only matters if buffering can't keep up. |
-| `activateAfterIdle` | none | Forces buffered observations to activate after a period of inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, or duration strings like `"5m"` or `"1hr"`. Set this to your prompt cache TTL if you want activation to happen before the next cold prompt. |
+| `activateAfterIdle` | none | Forces buffered observations to activate after a period of inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, duration strings like `"5m"` or `"1hr"`, or `"auto"` for a provider-aware prompt cache TTL. |
 | `activateOnProviderChange` | `false` | Forces buffered observations to activate when the next step uses a different `provider/model` than the one that produced the latest assistant step. Use this when switching providers or models would invalidate prompt cache reuse. |
 | `reflection.bufferActivation` | `0.5` | When to start background reflection. `0.5` means reflection begins when observations reach 50% of the `observationTokens` threshold. |
 | `reflection.activateAfterIdle` | none | Opts buffered reflections into idle activation. Reflections don't inherit top-level `activateAfterIdle`. |
 | `reflection.activateOnProviderChange` | `false` | Opts buffered reflections into provider-change activation. Reflections don't inherit top-level `activateOnProviderChange`. |
 | `reflection.blockAfter` | `1.2` | Safety threshold for reflection, same logic as observation. |
 
-If you're relying on prompt caching, set `activateAfterIdle` to match your cache TTL. That way, once a thread has been idle long enough for the cache to expire, the next request can activate buffered observations first and send a smaller compressed context window.
+If you're relying on prompt caching, set `activateAfterIdle` to `"auto"` or to a specific cache TTL. That way, once a thread has been idle long enough for the cache to expire, the next request can activate buffered observations first and send a smaller compressed context window.
+
+With `"auto"`, Mastra chooses an idle activation TTL from the active model provider:
+
+| Provider | Auto TTL |
+| - | - |
+| Anthropic, OpenRouter, unknown providers, xAI | 5 minutes |
+| DeepSeek | 1 hour |
+| Google Gemini | 24 hours |
+| Groq | 2 hours |
+| OpenAI with `providerOptions.openai.promptCacheRetention: "24h"` | 1 hour |
+| OpenAI with `providerOptions.openai.promptCacheRetention: "in_memory"` | 5 minutes |
+| OpenAI `gpt-4*`, `gpt-5`, `gpt-5-*`, `gpt-5.1*`, `gpt-5.2*`, `gpt-5.3*`, and `gpt-5.4*` | 5 minutes |
+| Other OpenAI models | 1 hour |
 
 ```typescript
 const memory = new Memory({
   options: {
     observationalMemory: {
       model: 'google/gemini-2.5-flash',
-      activateAfterIdle: '5m',
+      activateAfterIdle: 'auto',
       activateOnProviderChange: true,
     },
   },
 })
 ```
 
-With a 5-minute prompt cache TTL, this activates buffered observations after 5 minutes of inactivity so the next uncached prompt uses compressed observations instead of a larger raw message window. If you prefer, `300_000` works the same way.
+With `"auto"`, this activates buffered observations based on the active provider's prompt cache behavior so the next uncached prompt uses compressed observations instead of a larger raw message window. If you prefer a fixed 5-minute TTL, use `"5m"` or `300_000`.
 
-Changing model or providers mid-thread will invalidate the prompt cache. If your agent can switch between providers or models mid-thread, `activateOnProviderChange: true` forces buffered observations to activate before the new provider runs. That avoids sending a large raw window to a provider that can't reuse the previous prompt cache.
+Changing models or providers mid-thread will invalidate the prompt cache. If your agent can switch between providers or models mid-thread, `activateOnProviderChange: true` forces buffered observations to activate before the new provider runs. That avoids sending a large raw window to a provider that can't reuse the previous prompt cache.
 
 ### Disabling
 
 
@@ -66,9 +66,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
   },
   {
     name: 'activateAfterIdle',
-    type: 'number | string | false',
+    type: 'number | string | false | "auto"',
     description:
-      'Time before buffered observations are forced to activate after inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, duration strings like `"5m"` or `"1hr"`, or `false` to disable inherited observation idle activation. Reflections do not inherit this setting. Use `reflection.activateAfterIdle` to opt reflections into idle activation.',
+      'Time before buffered observations are forced to activate after inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, duration strings like `"5m"` or `"1hr"`, `"auto"` for a provider-aware prompt cache TTL, or `false` to disable inherited observation idle activation. Reflections do not inherit this setting. Use `reflection.activateAfterIdle` to opt reflections into idle activation.',
     isOptional: true,
   },
   {
@@ -204,9 +204,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
           },
           {
             name: 'activateAfterIdle',
-            type: 'number | string | false',
+            type: 'number | string | false | "auto"',
             description:
-              'Time before buffered observations are forced to activate after inactivity. Accepts milliseconds, a duration string, or `false`. If unset, the top-level `activateAfterIdle` value is used for observations. Set `false` to disable the top-level idle setting for observations.',
+              'Time before buffered observations are forced to activate after inactivity. Accepts milliseconds, a duration string, `"auto"` for a provider-aware prompt cache TTL, or `false`. If unset, the top-level `activateAfterIdle` value is used for observations. Set `false` to disable the top-level idle setting for observations.',
             isOptional: true,
           },
           {
@@ -305,9 +305,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
           },
           {
             name: 'activateAfterIdle',
-            type: 'number | string | false',
+            type: 'number | string | false | "auto"',
             description:
-              'Time before buffered reflections are forced to activate after inactivity. Accepts milliseconds, a duration string, or `false`. Reflections do not inherit top-level `activateAfterIdle`; set this explicitly to opt reflections into idle activation.',
+              'Time before buffered reflections are forced to activate after inactivity. Accepts milliseconds, a duration string, `"auto"` for a provider-aware prompt cache TTL, or `false`. Reflections do not inherit top-level `activateAfterIdle`; set this explicitly to opt reflections into idle activation.',
             isOptional: true,
           },
           {
 
@@ -112,7 +112,7 @@ export function getDynamicMemory(storage: MastraCompositeStore, vector?: MastraV
           temporalMarkers: true,
           retrieval: vector ? { vector: true } : true,
           scope: omScope,
-          activateAfterIdle: '5m',
+          activateAfterIdle: 'auto',
           activateOnProviderChange: true,
           observation: {
             bufferTokens: isResourceScope ? false : 1 / 5,
 
@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { IdleCounterComponent, formatIdleDuration } from '../idle-counter.js';
+
+describe('formatIdleDuration', () => {
+  it('formats idle time from whole minutes up through larger units', () => {
+    expect(formatIdleDuration(1)).toBe('1 minute');
+    expect(formatIdleDuration(15)).toBe('15 minutes');
+    expect(formatIdleDuration(60)).toBe('1 hour');
+    expect(formatIdleDuration(96)).toBe('1 hour 36 minutes');
+    expect(formatIdleDuration(24 * 60)).toBe('1 day');
+    expect(formatIdleDuration(31 * 24 * 60)).toBe('1 month 1 day');
+    expect(formatIdleDuration(365 * 24 * 60)).toBe('1 year');
+  });
+});
+
+describe('IdleCounterComponent', () => {
+  it('stays hidden until one minute idle, then renders like a temporal-gap marker', () => {
+    const component = new IdleCounterComponent();
+
+    expect(component.render(80)).toEqual([]);
+
+    component.setIdleStartedAt(0, 59_999);
+    expect(component.render(80)).toEqual([]);
+
+    component.update(60_000);
+    expect(component.render(80).join('\n')).toContain('1 minute idle');
+    expect(component.render(80).join('\n')).not.toContain('⏳');
+
+    component.update(96 * 60_000);
+    expect(component.render(80).join('\n')).toContain('1 hour 36 minutes idle');
+
+    component.setIdleStartedAt(undefined);
+    expect(component.render(80)).toEqual([]);
+  });
+});
@@ -46,6 +46,20 @@ describe('OMMarkerComponent activation rendering', () => {
     expect(activationText).not.toContain('TTL');
   });
 
+  it('renders combined observation activation counts', () => {
+    const activationMarker = new OMMarkerComponent({
+      type: 'om_activation',
+      operationType: 'observation',
+      tokensActivated: 9300,
+      observationTokens: 525,
+      activationCount: 2,
+    });
+
+    const activationText = stripAnsi(activationMarker.render(120).join('\n'));
+
+    expect(activationText).toContain('✓ Activated 2 observations: -9.3k msg tokens, +0.5k obs tokens');
+  });
+
   it('renders provider-change activation as a separate muted line', () => {
     const providerChangeMarker = new OMMarkerComponent({
       type: 'om_activation_provider_change',
 
@@ -0,0 +1,81 @@
+/**
+ * Live idle-time indicator shown above the user input after an agent run completes.
+ */
+
+import { Container, Text } from '@mariozechner/pi-tui';
+import { BOX_INDENT, theme } from '../theme.js';
+
+const MINUTE_MS = 60_000;
+const HOUR_MINUTES = 60;
+const DAY_MINUTES = HOUR_MINUTES * 24;
+const MONTH_MINUTES = DAY_MINUTES * 30;
+const YEAR_MINUTES = DAY_MINUTES * 365;
+
+export class IdleCounterComponent extends Container {
+  private idleStartedAt?: number;
+  private textChild: Text;
+
+  constructor() {
+    super();
+    this.textChild = new Text('', BOX_INDENT, 0);
+    this.addChild(this.textChild);
+  }
+
+  setIdleStartedAt(idleStartedAt: number | undefined, now = Date.now()): void {
+    this.idleStartedAt = idleStartedAt;
+    this.update(now);
+  }
+
+  update(now = Date.now()): void {
+    if (this.idleStartedAt === undefined) {
+      this.textChild.setText('');
+      return;
+    }
+
+    const idleMinutes = Math.floor((now - this.idleStartedAt) / MINUTE_MS);
+    if (idleMinutes < 1) {
+      this.textChild.setText('');
+      return;
+    }
+
+    this.textChild.setText(theme.fg('dim', `  ${formatIdleDuration(idleMinutes)} idle`));
+  }
+
+  render(width: number): string[] {
+    if (this.idleStartedAt === undefined || this.textChild.render(width).join('').length === 0) {
+      return [];
+    }
+
+    return super.render(width);
+  }
+}
+
+export function formatIdleDuration(totalMinutes: number): string {
+  const minutes = Math.max(1, Math.floor(totalMinutes));
+  const units = [
+    { name: 'year', minutes: YEAR_MINUTES },
+    { name: 'month', minutes: MONTH_MINUTES },
+    { name: 'day', minutes: DAY_MINUTES },
+    { name: 'hour', minutes: HOUR_MINUTES },
+    { name: 'minute', minutes: 1 },
+  ];
+
+  let remaining = minutes;
+  const parts: string[] = [];
+
+  for (const unit of units) {
+    const value = Math.floor(remaining / unit.minutes);
+    if (value === 0) continue;
+
+    parts.push(formatUnit(value, unit.name));
+    remaining %= unit.minutes;
+
+    if (parts.length === 2) break;
+  }
+
+  return parts.join(' ');
+}
+
+function formatUnit(value: number, unit: string): string {
+  return `${value} ${unit}${value === 1 ? '' : 's'}`;
+}
@@ -70,6 +70,7 @@ export type OMMarkerData =
       operationType: 'observation' | 'reflection';
       tokensActivated: number;
       observationTokens: number;
+      activationCount?: number;
     }
   | {
       type: 'om_activation_ttl';
@@ -165,7 +166,9 @@ function formatMarker(data: OMMarkerData): string {
       }
       const msgTokens = formatTokens(data.tokensActivated);
       const obsTokens = formatTokens(data.observationTokens);
-      return theme.fg('success', `  ✓ Activated observations: -${msgTokens} msg tokens, +${obsTokens} obs tokens`);
+      const label =
+        data.activationCount && data.activationCount > 1 ? `${data.activationCount} observations` : 'observations';
+      return theme.fg('success', `  ✓ Activated ${label}: -${msgTokens} msg tokens, +${obsTokens} obs tokens`);
     }
     case 'om_activation_ttl': {
       return theme.fg(
 
@@ -0,0 +1,41 @@
+import { Container } from '@mariozechner/pi-tui';
+import stripAnsi from 'strip-ansi';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { TUIState } from '../../state.js';
+import { handleOMActivation } from '../om.js';
+import type { EventHandlerContext } from '../types.js';
+
+function createCtx() {
+  const state = {
+    chatContainer: new Container(),
+    ui: { requestRender: vi.fn() },
+  } as unknown as TUIState;
+
+  const ctx = { state } as EventHandlerContext;
+
+  return { ctx, state };
+}
+
+describe('handleOMActivation', () => {
+  it('combines consecutive observation activation markers into one line', () => {
+    const { ctx, state } = createCtx();
+
+    handleOMActivation(ctx, 'observation', 7_300, 400);
+    handleOMActivation(ctx, 'observation', 2_000, 125);
+
+    expect(state.chatContainer.children).toHaveLength(1);
+    const text = stripAnsi(state.chatContainer.render(120).join('\n'));
+    expect(text).toContain('Activated 2 observations: -9.3k msg tokens, +0.5k obs tokens');
+  });
+
+  it('does not combine activations separated by another marker', () => {
+    const { ctx, state } = createCtx();
+
+    handleOMActivation(ctx, 'observation', 7_300, 400);
+    state.chatContainer.addChild(new Container());
+    handleOMActivation(ctx, 'observation', 2_000, 125);
+
+    expect(state.chatContainer.children).toHaveLength(3);
+  });
+});
Original file line number	Diff line number	Diff line change
@@ -66,9 +66,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
`66`	`66`	`},`
`67`	`67`	`{`
`68`	`68`	`name: 'activateAfterIdle',`
`69`		`- type: 'number \| string \| false',`
	`69`	`+ type: 'number \| string \| false \| "auto"',`
`70`	`70`	`description:`
`71`		- 'Time before buffered observations are forced to activate after inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, duration strings like `"5m"` or `"1hr"`, or `false` to disable inherited observation idle activation. Reflections do not inherit this setting. Use `reflection.activateAfterIdle` to opt reflections into idle activation.',
	`71`	+ 'Time before buffered observations are forced to activate after inactivity, even before `observation.messageTokens` is reached. Accepts a numeric millisecond value such as `300_000`, duration strings like `"5m"` or `"1hr"`, `"auto"` for a provider-aware prompt cache TTL, or `false` to disable inherited observation idle activation. Reflections do not inherit this setting. Use `reflection.activateAfterIdle` to opt reflections into idle activation.',
`72`	`72`	`isOptional: true,`
`73`	`73`	`},`
`74`	`74`	`{`
@@ -204,9 +204,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
`204`	`204`	`},`
`205`	`205`	`{`
`206`	`206`	`name: 'activateAfterIdle',`
`207`		`- type: 'number \| string \| false',`
	`207`	`+ type: 'number \| string \| false \| "auto"',`
`208`	`208`	`description:`
`209`		- 'Time before buffered observations are forced to activate after inactivity. Accepts milliseconds, a duration string, or `false`. If unset, the top-level `activateAfterIdle` value is used for observations. Set `false` to disable the top-level idle setting for observations.',
	`209`	+ 'Time before buffered observations are forced to activate after inactivity. Accepts milliseconds, a duration string, `"auto"` for a provider-aware prompt cache TTL, or `false`. If unset, the top-level `activateAfterIdle` value is used for observations. Set `false` to disable the top-level idle setting for observations.',
`210`	`210`	`isOptional: true,`
`211`	`211`	`},`
`212`	`212`	`{`
@@ -305,9 +305,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
`305`	`305`	`},`
`306`	`306`	`{`
`307`	`307`	`name: 'activateAfterIdle',`
`308`		`- type: 'number \| string \| false',`
	`308`	`+ type: 'number \| string \| false \| "auto"',`
`309`	`309`	`description:`
`310`		- 'Time before buffered reflections are forced to activate after inactivity. Accepts milliseconds, a duration string, or `false`. Reflections do not inherit top-level `activateAfterIdle`; set this explicitly to opt reflections into idle activation.',
	`310`	+ 'Time before buffered reflections are forced to activate after inactivity. Accepts milliseconds, a duration string, `"auto"` for a provider-aware prompt cache TTL, or `false`. Reflections do not inherit top-level `activateAfterIdle`; set this explicitly to opt reflections into idle activation.',
`311`	`311`	`isOptional: true,`
`312`	`312`	`},`
`313`	`313`	`{`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,7 @@ export type OMMarkerData =`
`70`	`70`	`operationType: 'observation' \| 'reflection';`
`71`	`71`	`tokensActivated: number;`
`72`	`72`	`observationTokens: number;`
	`73`	`+ activationCount?: number;`
`73`	`74`	`}`
`74`	`75`	`\| {`
`75`	`76`	`type: 'om_activation_ttl';`
`@@ -165,7 +166,9 @@ function formatMarker(data: OMMarkerData): string {`
`165`	`166`	`}`
`166`	`167`	`const msgTokens = formatTokens(data.tokensActivated);`
`167`	`168`	`const obsTokens = formatTokens(data.observationTokens);`
`168`		- return theme.fg('success', ` ✓ Activated observations: -${msgTokens} msg tokens, +${obsTokens} obs tokens`);
	`169`	`+ const label =`
	`170`	+ data.activationCount && data.activationCount > 1 ? `${data.activationCount} observations` : 'observations';
	`171`	+ return theme.fg('success', ` ✓ Activated ${label}: -${msgTokens} msg tokens, +${obsTokens} obs tokens`);
`169`	`172`	`}`
`170`	`173`	`case 'om_activation_ttl': {`
`171`	`174`	`return theme.fg(`