@persistio/openclaw-plugin 0.1.6 → 0.1.8

package/src/index.ts

@@ -29,6 +29,47 @@ const DEFAULT_SEND_ROLES: PersistioConfig['send']['roles'] = {
 const MESSAGE_KEY_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_TRACKED_SESSIONS = 250;
 const MAX_SENT_KEYS_PER_SESSION = 2000;
+const RECALL_CIRCUIT_BREAKER_FAILURE_THRESHOLD = 3;
+const RECALL_CIRCUIT_BREAKER_COOLDOWN_MS = 60_000;
+const RECALL_GUARD_MARGIN_MS = 250;
+const DEFAULT_TOKEN_BUDGET = 400;
+const DEFAULT_RECALL_TOP_K = 4;
+const DEFAULT_RECALL_TIMEOUT_MS = 1500;
+const MAX_MEMORY_SEARCH_RESULTS = 8;
+const MAX_PROMPT_MEMORY_ITEM_CHARS = 500;
+const MAX_MEMORY_SNIPPET_CHARS = 360;
+
+interface PluginLogger {
+  debug?: (message: string) => void;
+  warn?: (message: string) => void;
+}
+
+class RecallCircuitBreaker {
+  private consecutiveFailures = 0;
+  private openedUntil = 0;
+
+  canAttempt(now = Date.now()): boolean {
+    return now >= this.openedUntil;
+  }
+
+  remainingMs(now = Date.now()): number {
+    return Math.max(0, this.openedUntil - now);
+  }
+
+  recordSuccess(): void {
+    this.consecutiveFailures = 0;
+    this.openedUntil = 0;
+  }
+
+  recordFailure(now = Date.now()): boolean {
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= RECALL_CIRCUIT_BREAKER_FAILURE_THRESHOLD) {
+      this.openedUntil = now + RECALL_CIRCUIT_BREAKER_COOLDOWN_MS;
+      return true;
+    }
+    return false;
+  }
+}
 
 function resolveSendConfig(raw: Record<string, unknown>): PersistioConfig['send'] {
   const send = raw['send'];
@@ -54,15 +95,37 @@ function resolveRecallMinSimilarity(value: unknown): number | undefined {
     : undefined;
 }
 
+function resolvePositiveInteger(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 1
+    ? Math.floor(value)
+    : fallback;
+}
+
+function resolveBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function resolveOptionalPositiveInteger(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 1
+    ? Math.floor(value)
+    : undefined;
+}
+
+function clampPositiveInteger(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+
 function resolveConfig(raw: unknown): PersistioConfig {
   const c = (raw ?? {}) as Record<string, unknown>;
   return {
     baseURL: typeof c['baseURL'] === 'string' ? c['baseURL'] : '',
     apiKey: typeof c['apiKey'] === 'string' ? c['apiKey'] : '',
-    tokenBudget: typeof c['tokenBudget'] === 'number' ? c['tokenBudget'] : 2000,
-    recallTopK: typeof c['recallTopK'] === 'number' ? c['recallTopK'] : 10,
+    tokenBudget: resolvePositiveInteger(c['tokenBudget'], DEFAULT_TOKEN_BUDGET),
+    recallTopK: resolvePositiveInteger(c['recallTopK'], DEFAULT_RECALL_TOP_K),
     recallMinSimilarity: resolveRecallMinSimilarity(c['recallMinSimilarity']),
-    recallTimeout: typeof c['recallTimeout'] === 'number' ? c['recallTimeout'] : 5000,
+    recallTimeout: resolvePositiveInteger(c['recallTimeout'], DEFAULT_RECALL_TIMEOUT_MS),
+    recallIncludePending: resolveBoolean(c['recallIncludePending'], false),
+    includeRelatedMemories: resolveBoolean(c['includeRelatedMemories'], false),
     ingest: resolveIngestPolicy(c['ingest']),
     send: resolveSendConfig(c),
   };
@@ -139,29 +202,37 @@ function buildRecallQuery(event: { prompt?: string; messages?: unknown[] }): str
   return truncate(parts.join('\n'), 600);
 }
 
-function buildMemoryBlock(bundle: RecallBundle, budget: number, relatedBundle?: RecallBundle): string {
+function toStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function buildMemoryBlock(bundle: RecallBundle | undefined, budget: number, relatedBundle?: RecallBundle): string {
+  if (!bundle || typeof bundle !== 'object') return '';
+
   const sections: Array<{ title: string; items: string[] }> = [
-    { title: 'Behavioural rules', items: bundle.user_rules },
-    { title: 'Preferences', items: bundle.user_preferences },
-    { title: 'Task patterns', items: bundle.task_patterns },
-    { title: 'Workflows', items: bundle.workflows },
-    { title: 'Project', items: bundle.project },
-    { title: 'Constraints', items: bundle.constraints },
-    { title: 'Decisions', items: bundle.decisions },
-    { title: 'System facts', items: bundle.system_facts },
-    { title: 'Domain knowledge', items: bundle.domain_knowledge },
+    { title: 'Behavioural rules', items: [...toStringArray(bundle.global_user_rules), ...toStringArray(bundle.user_rules)] },
+    { title: 'Preferences', items: toStringArray(bundle.user_preferences) },
+    { title: 'Task patterns', items: toStringArray(bundle.task_patterns) },
+    { title: 'Workflows', items: toStringArray(bundle.workflows) },
+    { title: 'Project', items: toStringArray(bundle.project) },
+    { title: 'Constraints', items: toStringArray(bundle.constraints) },
+    { title: 'Decisions', items: toStringArray(bundle.decisions) },
+    { title: 'System facts', items: toStringArray(bundle.system_facts) },
+    { title: 'Domain knowledge', items: toStringArray(bundle.domain_knowledge) },
   ];
-  if (relatedBundle) {
+  if (relatedBundle && typeof relatedBundle === 'object') {
     sections.push(
-      { title: 'Related behavioural rules', items: relatedBundle.user_rules },
-      { title: 'Related preferences', items: relatedBundle.user_preferences },
-      { title: 'Related task patterns', items: relatedBundle.task_patterns },
-      { title: 'Related workflows', items: relatedBundle.workflows },
-      { title: 'Related project', items: relatedBundle.project },
-      { title: 'Related constraints', items: relatedBundle.constraints },
-      { title: 'Related decisions', items: relatedBundle.decisions },
-      { title: 'Related system facts', items: relatedBundle.system_facts },
-      { title: 'Related domain knowledge', items: relatedBundle.domain_knowledge },
+      { title: 'Related behavioural rules', items: toStringArray(relatedBundle.user_rules) },
+      { title: 'Related preferences', items: toStringArray(relatedBundle.user_preferences) },
+      { title: 'Related task patterns', items: toStringArray(relatedBundle.task_patterns) },
+      { title: 'Related workflows', items: toStringArray(relatedBundle.workflows) },
+      { title: 'Related project', items: toStringArray(relatedBundle.project) },
+      { title: 'Related constraints', items: toStringArray(relatedBundle.constraints) },
+      { title: 'Related decisions', items: toStringArray(relatedBundle.decisions) },
+      { title: 'Related system facts', items: toStringArray(relatedBundle.system_facts) },
+      { title: 'Related domain knowledge', items: toStringArray(relatedBundle.domain_knowledge) },
     );
   }
 
@@ -179,10 +250,10 @@ function buildMemoryBlock(bundle: RecallBundle, budget: number, relatedBundle?:
     const includedItems: string[] = [];
 
     for (const item of candidates) {
-      const line = `- ${item}`;
+      const line = `- ${truncate(item.replace(/\s+/g, ' ').trim(), MAX_PROMPT_MEMORY_ITEM_CHARS)}`;
       const cost = estimateTokens(`\n${line}`);
       if (tentativeUsed + cost > budget) {
-        return lines.length > 1 ? lines.join('\n') : '';
+        break;
       }
       includedItems.push(line);
       tentativeUsed += cost;
@@ -329,8 +400,88 @@ function isTimeoutLikeError(err: unknown): boolean {
   return message.includes('timeout') || message.includes('aborted');
 }
 
+async function runGuardedRecall<T>(args: {
+  operation: string;
+  timeoutMs: number;
+  fallback: T;
+  breaker: RecallCircuitBreaker;
+  logger?: PluginLogger;
+  run: () => Promise<T>;
+}): Promise<T> {
+  const now = Date.now();
+  if (!args.breaker.canAttempt(now)) {
+    args.logger?.warn?.(
+      `openclaw-persistio: ${args.operation} skipped; recall circuit breaker open `
+      + `for ${args.breaker.remainingMs(now)}ms`,
+    );
+    return args.fallback;
+  }
+
+  try {
+    const result = await withPluginDeadline(args.operation, args.timeoutMs + RECALL_GUARD_MARGIN_MS, args.run);
+    args.breaker.recordSuccess();
+    return result;
+  } catch (err) {
+    const opened = args.breaker.recordFailure();
+    args.logger?.warn?.(
+      `openclaw-persistio: ${args.operation} failed open: ${String(err)}`
+      + (opened ? `; recall circuit breaker open for ${RECALL_CIRCUIT_BREAKER_COOLDOWN_MS}ms` : ''),
+    );
+    return args.fallback;
+  }
+}
+
+async function withPluginDeadline<T>(
+  operation: string,
+  timeoutMs: number,
+  run: () => Promise<T>,
+): Promise<T> {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return run();
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<never>((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      const err = new Error(`Persistio ${operation} exceeded plugin deadline after ${timeoutMs}ms`);
+      err.name = 'TimeoutError';
+      reject(err);
+    }, timeoutMs);
+  });
+
+  try {
+    return await Promise.race([run(), deadline]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 const PERSISTIO_MEMORY_PATH_PREFIX = 'persistio://memory/';
 
+function jsonResult(payload: unknown) {
+  return {
+    content: [{ type: 'text' as const, text: JSON.stringify(payload, null, 2) }],
+    details: payload,
+  };
+}
+
+function buildMemorySearchUnavailableResult(error: string) {
+  return {
+    results: [],
+    disabled: true,
+    unavailable: true,
+    error,
+    warning: 'Persistio memory retrieval is currently unavailable.',
+    action: 'Continue without memory for this turn.',
+    debug: { backend: 'builtin', provider: 'persistio' },
+  };
+}
+
+function resolveMemorySearchLimit(params: { maxResults?: number; fallback: number }): number {
+  const requested = resolveOptionalPositiveInteger(params.maxResults) ?? params.fallback;
+  return clampPositiveInteger(requested, 1, MAX_MEMORY_SEARCH_RESULTS);
+}
+
 function createClient(config: PersistioConfig, recallTopK = config.recallTopK): PersistioClient {
   return new PersistioClient({ ...config, recallTopK });
 }
@@ -379,7 +530,11 @@ async function probePersistio(client: PersistioClient): Promise<MemoryEmbeddingP
   }
 }
 
-function createMemorySearchManager(config: PersistioConfig): MemorySearchManager {
+function createMemorySearchManager(
+  config: PersistioConfig,
+  recallBreaker: RecallCircuitBreaker,
+  logger?: PluginLogger,
+): MemorySearchManager {
   const client = createClient(config);
 
   return {
@@ -398,9 +553,16 @@ function createMemorySearchManager(config: PersistioConfig): MemorySearchManager
         return [];
       }
 
-      const recallTopK = typeof opts?.maxResults === 'number' ? opts.maxResults : config.recallTopK;
+      const recallTopK = resolveMemorySearchLimit({ maxResults: opts?.maxResults, fallback: config.recallTopK });
       const recallClient = createClient(config, recallTopK);
-      const memories = await recallClient.recall(query);
+      const memories = await runGuardedRecall({
+        operation: 'memory search recall',
+        timeoutMs: config.recallTimeout,
+        fallback: [],
+        breaker: recallBreaker,
+        logger,
+        run: () => recallClient.recall(query),
+      });
 
       return memories
         .map((memory): MemorySearchResult => {
@@ -411,7 +573,7 @@ function createMemorySearchManager(config: PersistioConfig): MemorySearchManager
             endLine: 1,
             score,
             vectorScore: typeof memory.similarity === 'number' ? memory.similarity : undefined,
-            snippet: truncate(memory.data, 400),
+            snippet: truncate(memory.data.replace(/\s+/g, ' ').trim(), MAX_MEMORY_SNIPPET_CHARS),
             source: 'memory',
             citation: memory.subject,
           };
@@ -435,12 +597,17 @@ function createMemorySearchManager(config: PersistioConfig): MemorySearchManager
       }
 
       const text = formatMemoryDocument(memory);
+      const from = params.from ?? 1;
+      const lines = text.split('\n');
+      const startIndex = Math.max(0, from - 1);
+      const requestedLines = params.lines && params.lines > 0 ? params.lines : 40;
+      const sliced = lines.slice(startIndex, startIndex + requestedLines).join('\n');
       return {
         path: params.relPath,
-        text,
-        truncated: false,
-        from: params.from ?? 1,
-        lines: params.lines,
+        text: truncate(sliced, 2000),
+        truncated: startIndex + requestedLines < lines.length || sliced.length > 2000,
+        from,
+        lines: requestedLines,
       };
     },
 
@@ -469,11 +636,11 @@ function createMemorySearchManager(config: PersistioConfig): MemorySearchManager
   };
 }
 
-function createMemoryRuntime(config: PersistioConfig) {
+function createMemoryRuntime(config: PersistioConfig, recallBreaker: RecallCircuitBreaker, logger?: PluginLogger) {
   return {
     async getMemorySearchManager() {
       return {
-        manager: createMemorySearchManager(config),
+        manager: createMemorySearchManager(config, recallBreaker, logger),
       };
     },
 
@@ -483,6 +650,26 @@ function createMemoryRuntime(config: PersistioConfig) {
   };
 }
 
+function buildPersistioMemoryPromptSection({ availableTools }: { availableTools: Set<string> }): string[] {
+  const hasMemorySearch = availableTools.has('memory_search');
+  const hasMemoryGet = availableTools.has('memory_get');
+  if (!hasMemorySearch && !hasMemoryGet) return [];
+
+  if (hasMemorySearch && hasMemoryGet) {
+    return [
+      '## Memory Recall',
+      'Persistio is the active memory provider. For prior work, decisions, dates, people, preferences, or todos, use memory_search first and memory_get only for a bounded exact read of a returned persistio://memory/<id> path.',
+      '',
+    ];
+  }
+
+  return [
+    '## Memory Recall',
+    'Persistio is the active memory provider. Use the available memory tool for prior work, decisions, dates, people, preferences, or todos when memory context is needed.',
+    '',
+  ];
+}
+
 export default definePluginEntry({
   id: 'openclaw-persistio',
   name: 'Persistio Memory',
@@ -497,10 +684,12 @@ export default definePluginEntry({
     }
 
     const client = createClient(cfg);
+    const recallBreaker = new RecallCircuitBreaker();
     const sentMessageKeysBySession = new Map<string, SessionMessageKeyStore>();
     const pendingMessageKeysBySession = new Map<string, SessionMessageKeyStore>();
     api.registerMemoryCapability({
-      runtime: createMemoryRuntime(cfg),
+      promptBuilder: buildPersistioMemoryPromptSection,
+      runtime: createMemoryRuntime(cfg, recallBreaker, api.logger),
     });
 
     // -------------------------------------------------------------------------
@@ -509,16 +698,25 @@ export default definePluginEntry({
     // Return: { appendSystemContext?: string }
     // -------------------------------------------------------------------------
     api.on('before_prompt_build', async (event) => {
-      try {
-        const query = buildRecallQuery(event);
-        const recall = await client.recallBundle(query);
-        const block = buildMemoryBlock(recall.bundle, cfg.tokenBudget, recall.related_bundle);
-        if (!block) return;
-        return { appendSystemContext: block };
-      } catch (err) {
-        api.logger?.warn?.(`openclaw-persistio: recall error: ${String(err)}`);
-      }
-    });
+      const query = buildRecallQuery(event);
+      const block = await runGuardedRecall({
+        operation: 'before_prompt_build recall',
+        timeoutMs: cfg.recallTimeout,
+        fallback: '',
+        breaker: recallBreaker,
+        logger: api.logger,
+        run: async () => {
+          const recall = await client.recallBundle(query, undefined, { includeRelated: cfg.includeRelatedMemories });
+          return buildMemoryBlock(
+            recall.bundle,
+            cfg.tokenBudget,
+            cfg.includeRelatedMemories ? recall.related_bundle : undefined,
+          );
+        },
+      });
+      if (!block) return;
+      return { appendSystemContext: block };
+    }, { timeoutMs: cfg.recallTimeout + RECALL_GUARD_MARGIN_MS + 250 });
 
     // -------------------------------------------------------------------------
     // agent_end — ingest new turn messages (fire and forget)
@@ -622,46 +820,142 @@ export default definePluginEntry({
     // AgentToolResult: { content: Array<{ type: "text", text: string }>, details: unknown }
     // -------------------------------------------------------------------------
 
+    const memoryManager = createMemorySearchManager(cfg, recallBreaker, api.logger);
+
     api.registerTool({
       name: 'memory_search',
-      label: 'Search Memory',
-      description: 'Search persistent memory for relevant facts from past conversations.',
+      label: 'Memory Search',
+      description: 'Search Persistio semantic memory. Returns bounded structured results with persistio://memory/<id> paths for memory_get.',
       parameters: Type.Object({
-        query: Type.String({ description: 'What to search for' }),
-        top_k: Type.Optional(Type.Number({ description: 'Max results to return' })),
-      }),
+        query: Type.String({ description: 'Search query' }),
+        maxResults: Type.Optional(Type.Number({ description: 'Maximum results to return' })),
+        minScore: Type.Optional(Type.Number({ description: 'Optional minimum score from 0 to 1' })),
+        corpus: Type.Optional(Type.Union([
+          Type.Literal('memory'),
+          Type.Literal('wiki'),
+          Type.Literal('all'),
+          Type.Literal('sessions'),
+        ], { description: 'Persistio supports memory corpus results' })),
+      }, { additionalProperties: false }),
       async execute(_id, params) {
-        const p = params as { query: string; top_k?: number };
-        const overrideTopK = typeof p.top_k === 'number' ? p.top_k : cfg.recallTopK;
-        const overrideCfg = { ...cfg, recallTopK: overrideTopK };
-        const c = new PersistioClient(overrideCfg);
-        const memories = await c.recall(p.query);
-        const text = memories.length > 0
-          ? memories.map(m => `- ${m.data} [${m.subject}]`).join('\n')
-          : 'No memories found.';
-        return { content: [{ type: 'text' as const, text }], details: null };
+        const p = params as {
+          query?: string;
+          maxResults?: number;
+          minScore?: number;
+          corpus?: 'memory' | 'wiki' | 'all' | 'sessions';
+        };
+        const query = typeof p.query === 'string' ? p.query.trim() : '';
+        if (!query) {
+          return jsonResult(buildMemorySearchUnavailableResult('memory_search requires a non-empty query'));
+        }
+
+        const maxResults = resolveMemorySearchLimit({
+          maxResults: p.maxResults,
+          fallback: cfg.recallTopK,
+        });
+        const requestedCorpus = p.corpus ?? 'memory';
+        const sources: Array<'memory' | 'sessions'> = requestedCorpus === 'sessions' || requestedCorpus === 'wiki'
+          ? []
+          : ['memory' as const];
+        const startedAt = Date.now();
+
+        try {
+          const results: MemorySearchResult[] = sources.length === 0
+            ? []
+            : await memoryManager.search(query, {
+              maxResults,
+              minScore: p.minScore,
+              sources,
+            });
+
+          return jsonResult({
+            results: results.map((result) => ({ ...result, corpus: 'memory' })),
+            provider: 'persistio',
+            model: undefined,
+            fallback: false,
+            citations: 'off',
+            mode: 'persistio',
+            debug: {
+              backend: 'builtin',
+              effectiveMode: 'persistio',
+              requestedCorpus,
+              searchMs: Math.max(0, Date.now() - startedAt),
+              hits: results.length,
+            },
+          });
+        } catch (err) {
+          return jsonResult(buildMemorySearchUnavailableResult(String(err)));
+        }
+      },
+    });
+
+    api.registerTool({
+      name: 'memory_get',
+      label: 'Memory Get',
+      description: 'Read a bounded exact Persistio memory document by persistio://memory/<id> path.',
+      parameters: Type.Object({
+        path: Type.String({ description: 'Memory path returned by memory_search' }),
+        from: Type.Optional(Type.Number({ description: 'Starting line, 1-based' })),
+        lines: Type.Optional(Type.Number({ description: 'Maximum number of lines to return' })),
+        corpus: Type.Optional(Type.Union([
+          Type.Literal('memory'),
+          Type.Literal('wiki'),
+          Type.Literal('all'),
+        ])),
+      }, { additionalProperties: false }),
+      async execute(_id, params) {
+        const p = params as { path?: string; from?: number; lines?: number; corpus?: 'memory' | 'wiki' | 'all' };
+        const path = typeof p.path === 'string' ? p.path : '';
+        if (p.corpus === 'wiki') {
+          return jsonResult({ path, text: '', disabled: true, error: 'Persistio does not provide a wiki corpus' });
+        }
+        try {
+          return jsonResult(await memoryManager.readFile({
+            relPath: path,
+            from: resolveOptionalPositiveInteger(p.from),
+            lines: resolveOptionalPositiveInteger(p.lines),
+          }));
+        } catch (err) {
+          return jsonResult({ path, text: '', disabled: true, error: String(err) });
+        }
       },
     });
 
     api.registerTool({
-      name: 'memory_add',
-      label: 'Add Memory',
-      description: 'Manually store a fact in persistent memory.',
+      name: 'persistio_memory_add',
+      label: 'Add Persistio Memory',
+      description: 'Manually store a fact in Persistio memory.',
       parameters: Type.Object({
         data: Type.String({ description: 'The fact to remember' }),
         subject: Type.String({ description: 'The entity or topic this fact is about' }),
       }),
       async execute(_id, params) {
         const p = params as { data: string; subject: string };
-        await client.addMemory(p.data, p.subject);
+        try {
+          await client.addMemory(p.data, p.subject);
+        } catch (err) {
+          if (isTimeoutLikeError(err)) {
+            api.logger?.warn?.(
+              `openclaw-persistio: persistio_memory_add timeout after ${cfg.ingest.timeoutMs}ms; outcome is ambiguous`,
+            );
+            return {
+              content: [{
+                type: 'text' as const,
+                text: 'Memory store request timed out; it may still complete. Check persistio_memory_list before retrying.',
+              }],
+              details: { ambiguous: true },
+            };
+          }
+          throw err;
+        }
         return { content: [{ type: 'text' as const, text: 'Memory stored.' }], details: null };
       },
-    });
+    }, { optional: true });
 
     api.registerTool({
-      name: 'memory_delete',
-      label: 'Delete Memory',
-      description: 'Delete a specific memory by its ID.',
+      name: 'persistio_memory_delete',
+      label: 'Delete Persistio Memory',
+      description: 'Delete a specific Persistio memory by its ID.',
       parameters: Type.Object({
         id: Type.String({ description: 'The memory ID to delete' }),
       }),
@@ -673,14 +967,14 @@ export default definePluginEntry({
     }, { optional: true });
 
     api.registerTool({
-      name: 'memory_list',
-      label: 'List Memories',
-      description: 'List all stored memories.',
+      name: 'persistio_memory_list',
+      label: 'List Persistio Memories',
+      description: 'List stored Persistio memories.',
       parameters: Type.Object({}),
       async execute(_id, _params) {
         const memories = await client.listMemories();
         const text = memories.length > 0
-          ? memories.map(m => `[${m.id}] ${m.data} (${m.subject})`).join('\n')
+          ? memories.map(m => `[${m.id}] ${truncate(m.data.replace(/\s+/g, ' ').trim(), MAX_MEMORY_SNIPPET_CHARS)} (${m.subject})`).join('\n')
           : 'No memories stored.';
         return { content: [{ type: 'text' as const, text }], details: null };
       },