@genesislcap/ai-assistant 14.497.0 → 14.499.0

package/dist/chat-driver.mjs

@@ -2589,6 +2589,7 @@ var META_EVENT_IMPORTANCE = {
   "provider.selected": "normal",
   "interaction.requested": "normal",
   "interaction.resolved": "normal",
+  "external-diagnostics.folded": "normal",
   "session.cleared": "normal",
   "session.switched": "low",
   "session.switch-deferred": "low",
@@ -3085,6 +3086,23 @@ var ChatDriver = class _ChatDriver extends EventTarget {
      * arrive. See {@link TurnSnapshot} for the captured shape.
      */
     this.turnSnapshots = [];
+    /**
+     * `turn` + `message` diagnostic-log entries harvested from an out-of-band source (a resolved
+     * interaction whose widget returned `InteractionResult.diagnostics` — e.g. a server-side
+     * ChatDriver's debug log). `event` entries are NOT kept here — they're folded into the session's
+     * meta-event registry via `mergeMetaEvents` (see `resolveInteraction`) so they inherit fresh host
+     * indices, and reach the log through `getMetaEvents`. Append-only; the host folds these into its
+     * debug log alongside this driver's own timeline. Not cleared here — it lives with the driver
+     * instance, like `turnSnapshots`, so a new chat (fresh driver) starts empty while a compaction
+     * (same instance) keeps it. (GENC-1461.)
+     */
+    this.externalDiagnostics = [];
+    /**
+     * Monotonic count of external-diagnostics batches harvested this driver-lifetime. Namespaces each
+     * batch's re-keyed `turn` entries so distinct server generations in one chat session can't collide
+     * on `turnIndex` in the forward-capture persister (which dedups turns by that key). (GENC-1461.)
+     */
+    this.externalDiagnosticsBatches = 0;
     /** Monotonic counter that survives agent swaps — useful for cross-referencing with history. */
     this.globalTurnIndex = 0;
     /**
@@ -3459,6 +3477,17 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   getTurnSnapshots() {
     return this.turnSnapshots;
   }
+  /**
+   * The `turn` + `message` diagnostic-log entries harvested from resolved interactions'
+   * `InteractionResult.diagnostics` (e.g. a server-side ChatDriver's collated debug log). The host
+   * concatenates these into its own debug log so `downloadDebugLog`/the persisted diagnostics stream
+   * include external-engine logs; `event` entries are excluded here because they're merged into the
+   * session's meta-event registry instead (see `resolveInteraction`) and reach the log via
+   * `getMetaEvents`. Opaque, chronologically sorted by the host at assemble time. (GENC-1461.)
+   */
+  getExternalDiagnostics() {
+    return this.externalDiagnostics;
+  }
   /**
    * Merge a sub-agent's turn snapshots into this driver's buffer so they surface
    * as `kind:'turn'` entries in the exported debug log. The child runs as a
@@ -3768,6 +3797,38 @@ Output format (strict):
     const interaction = this.pendingInteractions.get(interactionId);
     if (interaction) {
       if (interaction.timeoutHandle) clearTimeout(interaction.timeoutHandle);
+      const harvestedDiagnostics = result?.diagnostics;
+      if (Array.isArray(harvestedDiagnostics) && harvestedDiagnostics.length) {
+        const batch = this.externalDiagnosticsBatches += 1;
+        const externalEvents = [];
+        let turnCount = 0;
+        let messageCount = 0;
+        for (const raw of harvestedDiagnostics) {
+          if (!raw || typeof raw !== "object" || typeof raw.kind !== "string") {
+            continue;
+          }
+          const entry = raw;
+          if (entry.kind === "event") {
+            const { kind: _kind, ...event } = entry;
+            externalEvents.push(event);
+          } else if (entry.kind === "turn") {
+            this.externalDiagnostics.push({
+              ...entry,
+              turnIndex: `server-generation.${batch}:${turnCount}`
+            });
+            turnCount += 1;
+          } else if (entry.kind === "message") {
+            messageCount += 1;
+            this.externalDiagnostics.push(entry);
+          }
+        }
+        if (externalEvents.length) mergeMetaEvents(this.sessionKey, externalEvents);
+        recordMetaEvent(this.sessionKey, "external-diagnostics.folded", {
+          interactionId,
+          batch,
+          counts: { turn: turnCount, event: externalEvents.length, message: messageCount }
+        });
+      }
       const idx = this.history.findIndex((m) => m.interaction?.interactionId === interactionId);
       if (idx !== -1) {
         const costUsd = typeof result?.costUsd === "number" && Number.isFinite(result.costUsd) && result.costUsd > 0 ? result.costUsd : void 0;
@@ -5035,6 +5096,10 @@ var OrchestratingDriver = class extends EventTarget {
   getTurnSnapshots() {
     return this.chatDriver.getTurnSnapshots();
   }
+  /** Delegates to the inner {@link ChatDriver} — interactions resolve there, so it holds the buffer. */
+  getExternalDiagnostics() {
+    return this.chatDriver.getExternalDiagnostics();
+  }
   async getSuggestions(history, prompt2, count, allAgentInfo) {
     const pinned = this.resolvePinnedAgent();
     const candidates = pinned && isSpecialist(pinned) ? [pinned] : this.specialists;
@@ -5548,6 +5613,86 @@ var strictFallbackAgent = {
   fallback: true,
   systemPrompt: `You are a concise assistant. The user's request is outside your scope. Respond with a single short sentence stating what you can assist with. Do not elaborate. The available specialists are: {{agents}}.`
 };
+
+// src/utils/flatten-sub-agent-messages.ts
+function flattenSubAgentMessages(messages, prefix = "", depth = 0, subAgentOf) {
+  return messages.flatMap((m) => {
+    const breadcrumb = prefix ? `${prefix} \u203A ${m.agentName ?? "?"}` : m.agentName;
+    const traceCalls = m.toolCalls?.filter((tc) => tc.subAgentTrace?.length) ?? [];
+    const entry = {
+      kind: "message",
+      ...m,
+      // Move the (about-to-be-hoisted) child conversations out of the emitted tool
+      // calls. Setting it to `undefined` drops the key from the serialized export.
+      ...traceCalls.length > 0 && {
+        toolCalls: m.toolCalls.map(
+          (tc) => tc.subAgentTrace ? { ...tc, subAgentTrace: void 0 } : tc
+        )
+      },
+      // Mark + breadcrumb hoisted sub-agent messages; top-level (depth 0) stays as-is.
+      ...depth > 0 && {
+        agentName: breadcrumb,
+        subAgentName: m.agentName,
+        subAgentDepth: depth,
+        subAgentOf
+      }
+    };
+    if (traceCalls.length === 0) return [entry];
+    const hoisted = traceCalls.flatMap(
+      (tc) => flattenSubAgentMessages(tc.subAgentTrace, breadcrumb ?? "", depth + 1, tc.id)
+    );
+    return [entry, ...hoisted];
+  });
+}
+
+// src/state/persistence/build-timeline-entries.ts
+function buildTimelineEntries(input) {
+  const { turnSnapshots, messages, metaEvents } = input;
+  let lastFullPrompt;
+  let lastFullIndex = "";
+  const turns = turnSnapshots.map((t) => {
+    let { systemPrompt } = t;
+    if (systemPrompt != null && systemPrompt === lastFullPrompt) {
+      systemPrompt = `<repeated \u2014 identical to turn ${lastFullIndex}>`;
+    } else if (systemPrompt != null) {
+      lastFullPrompt = systemPrompt;
+      lastFullIndex = t.turnIndex;
+    }
+    return { kind: "turn", ...t, systemPrompt };
+  });
+  const messageEntries = flattenSubAgentMessages(messages);
+  const eventEntries = metaEvents.map((e) => ({ kind: "event", ...e }));
+  return [...messageEntries, ...turns, ...eventEntries];
+}
+
+// src/state/persistence/diagnostics.ts
+var KIND_RANK = { event: 0, turn: 1, message: 2 };
+var UNKNOWN_KIND_RANK = 99;
+function assembleDebugLog(entries, readme) {
+  const seen = /* @__PURE__ */ new Set();
+  let latestMeta;
+  const timeline = [];
+  for (const entry of entries) {
+    const id = JSON.stringify(entry);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    if (entry.kind === "meta-snapshot") {
+      if (!latestMeta || (entry.timestamp ?? "") >= (latestMeta.timestamp ?? "")) {
+        latestMeta = entry;
+      }
+    } else {
+      timeline.push(entry);
+    }
+  }
+  timeline.sort((a, b) => {
+    const ta = a.timestamp ?? "";
+    const tb = b.timestamp ?? "";
+    if (ta < tb) return -1;
+    if (ta > tb) return 1;
+    return (KIND_RANK[a.kind] ?? UNKNOWN_KIND_RANK) - (KIND_RANK[b.kind] ?? UNKNOWN_KIND_RANK);
+  });
+  return { readme, timeline, meta: latestMeta?.meta };
+}
 export {
   AgenticActivityBus,
   AnthropicProvider,
@@ -5559,10 +5704,16 @@ export {
   NOOP_ACTIVITY_BUS,
   OrchestratingDriver,
   REQUEST_CONTINUATION_TOOL,
+  SUPPORTED_ANTHROPIC_MODEL_IDS,
+  SUPPORTED_GEMINI_MODEL_IDS,
   agenticActivityBus,
+  assembleDebugLog,
+  buildTimelineEntries,
+  clearSession,
   defineAgent,
   defineStatefulAgent,
   friendlyFallbackAgent,
+  getMetaEvents,
   isObservableAIProviderRegistry,
   restoreMachine,
   strictFallbackAgent