fix(memory/typed-network): per-attempt 30s timeout on observer LLM invoke

The TypedNetworkObserver's underlying LLM adapter has no built-in
request timeout. A hung TCP socket or unresponsive provider could
deadlock long-running ingest pipelines indefinitely - at concurrency=1
a single hung request stalls every subsequent session forever.
Reproduced three times running Stage E Phase A on LongMemEval-S N=54
where each run hung 1.5-3 hours at 0% CPU on a stuck HTTPS connection
to the OpenAI/Cohere endpoint, while direct API tests via curl
returned in 0.5-1.3s.

Add Promise.race-based timeout with a clean clearTimeout in finally,
configurable via the new TypedNetworkObserverOptions.timeoutMs field
(default 30000ms). On timeout the attempt is abandoned and the
observer falls through to its existing retry / empty-result path -
the underlying request leaks its socket until GC / process exit but
ingest moves on.

This is a defense-in-depth fix; the underlying adapter SHOULD also
support AbortSignal but adding that requires extending the
ITypedExtractionLLM interface and updating every consumer's adapter,
which is invasive enough to defer.

Tests: 81/81 typed-network tests pass; new public surface
(timeoutMs option) is opt-in with a sane default that consumers
already get for free.

Author: jddunn

src/memory/retrieval/typed-network/TypedNetworkObserver.ts

@@ -70,6 +70,14 @@ export interface TypedNetworkObserverOptions {
   maxTokens?: number;
   /** Temperature. Default 0 for deterministic extraction. */
   temperature?: number;
+  /**
+   * Per-attempt request timeout in milliseconds. When the underlying
+   * `llm.invoke()` does not resolve within this window the attempt is
+   * abandoned and the observer falls through to the retry path. Used
+   * to prevent stale TCP sockets / hung OpenAI requests from
+   * deadlocking long-running ingest pipelines. Default 30 000 ms (30 s).
+   */
+  timeoutMs?: number;
 }
 
 /**
@@ -87,11 +95,13 @@ export class TypedNetworkObserver {
   private readonly llm: ITypedExtractionLLM;
   private readonly maxTokens: number;
   private readonly temperature: number;
+  private readonly timeoutMs: number;
 
   constructor(options: TypedNetworkObserverOptions) {
     this.llm = options.llm;
     this.maxTokens = options.maxTokens ?? 4096;
     this.temperature = options.temperature ?? 0;
+    this.timeoutMs = options.timeoutMs ?? 30_000;
   }
 
   /**
@@ -125,12 +135,21 @@ export class TypedNetworkObserver {
           ? baseUserPrompt
           : `${baseUserPrompt}\n\nThe previous response failed validation: ${lastValidationError}\nReturn JSON matching the schema strictly. Do not add commentary.`;
 
-      const raw = await this.llm.invoke({
-        system: TYPED_EXTRACTION_SYSTEM_PROMPT,
-        user: userPrompt,
-        maxTokens: this.maxTokens,
-        temperature: this.temperature,
-      });
+      // Race the underlying invoke against a per-attempt timeout. A
+      // hung TCP socket / unresponsive provider would otherwise
+      // deadlock long-running ingest pipelines — at concurrency=1 a
+      // single hung request stalls every subsequent session forever.
+      // The timeout fires from the agentos side without requiring the
+      // adapter to surface AbortSignal support; the underlying request
+      // is abandoned (its socket leaks until GC / process exit) but
+      // the observer moves to its retry path.
+      let raw: string;
+      try {
+        raw = await this.invokeWithTimeout(userPrompt);
+      } catch (err) {
+        lastValidationError = err instanceof Error ? err.message : String(err);
+        continue;
+      }
 
       const stripped = stripCodeFence(raw);
 
@@ -174,6 +193,37 @@ export class TypedNetworkObserver {
     // semantics.
     return [];
   }
+
+  /**
+   * Run `this.llm.invoke()` with a per-attempt timeout. Throws an
+   * `Error('TypedNetworkObserver: extraction timed out after Nms')`
+   * when the timer fires before the LLM responds. The timer is cleared
+   * on resolution to avoid leaking pending timeouts into subsequent
+   * extractions.
+   */
+  private async invokeWithTimeout(userPrompt: string): Promise<string> {
+    let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
+    const invokePromise = this.llm.invoke({
+      system: TYPED_EXTRACTION_SYSTEM_PROMPT,
+      user: userPrompt,
+      maxTokens: this.maxTokens,
+      temperature: this.temperature,
+    });
+    const timeoutPromise = new Promise<never>((_resolve, reject) => {
+      timeoutHandle = setTimeout(() => {
+        reject(
+          new Error(
+            `TypedNetworkObserver: extraction timed out after ${this.timeoutMs}ms`,
+          ),
+        );
+      }, this.timeoutMs);
+    });
+    try {
+      return await Promise.race([invokePromise, timeoutPromise]);
+    } finally {
+      if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+    }
+  }
 }
 
 /**