@genesislcap/ai-assistant 15.20.1-alpha-08bf7a668.0 → 15.20.2

package/dist/ai-assistant.api.json

@@ -2822,6 +2822,39 @@
               "parameters": [],
               "name": "getExternalDiagnostics"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@genesislcap/ai-assistant!AiDriver#getHistoryForPersistence:member(1)",
+              "docComment": "/**\n * The history a host should PERSIST — {@link AiDriver.getRawHistory} with tool payloads the driver has already condensed out of the model's context replaced by the stubs it sent (GENC-1566). Optional: a driver that does not implement tool-context condensation has nothing to project, and a caller falls back to {@link AiDriver.getRawHistory}.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "getHistoryForPersistence?(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": true,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "releaseTag": "Beta",
+              "overloadIndex": 1,
+              "parameters": [],
+              "name": "getHistoryForPersistence"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@genesislcap/ai-assistant!AiDriver#getInteractionContext:member(1)",
@@ -4991,6 +5024,42 @@
               "isAbstract": false,
               "name": "getHistory"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#getHistoryForPersistence:member(1)",
+              "docComment": "/**\n * The transcript as it should be **stored**: every tool payload the model has already stopped seeing replaced by the same stub it was sent (GENC-1566). Live history is untouched — this returns a copy.\n *\n * Condensation deliberately spares stored history, because the live transcript and the debug export both read it. A host writing that transcript to durable storage inherits the other half of that decision: it stores payloads the driver has already retired, on every autosave, for the life of the session. Measured on one small Create session — 58,187 chars, 7.4% of a 790 KB session object, across five payloads worth 14,434 tokens of context, written 86 times.\n *\n * Only already-collapsed payloads are touched, so this can never store a stub for something the model can still see, and it has no side effects (see `condenseForPersistence`, which is internal). A host that wants the unredacted transcript still calls {@link ChatDriver.getRawHistory}, and a diagnostics stream that keeps full payloads is unaffected — which is what makes the elision recoverable.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "getHistoryForPersistence(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "getHistoryForPersistence"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!ChatDriver#getInteractionContext:member(1)",
@@ -15544,6 +15613,42 @@
               "isAbstract": false,
               "name": "getExternalDiagnostics"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#getHistoryForPersistence:member(1)",
+              "docComment": "/**\n * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it is the only object that knows which payloads the model has stopped seeing (GENC-1566).\n *\n * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it wraps one — so without an explicit forward the optional call resolves to `undefined` and every host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly that way on a Create run: 10 `context.condensed` events fired, and the session still stored the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the tests passed, and the feature did nothing.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "getHistoryForPersistence(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ChatMessage",
+                  "canonicalReference": "@genesislcap/foundation-ai!ChatMessage:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "releaseTag": "Beta",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "getHistoryForPersistence"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/ai-assistant!OrchestratingDriver#getInteractionContext:member(1)",

package/dist/ai-assistant.d.ts

@@ -630,6 +630,13 @@ export declare interface AiDriver extends EventTarget {
      * Return the full, unredacted conversation history.
      */
     getRawHistory?(): readonly ChatMessage[];
+    /**
+     * The history a host should PERSIST — {@link AiDriver.getRawHistory} with tool payloads the
+     * driver has already condensed out of the model's context replaced by the stubs it sent
+     * (GENC-1566). Optional: a driver that does not implement tool-context condensation has nothing
+     * to project, and a caller falls back to {@link AiDriver.getRawHistory}.
+     */
+    getHistoryForPersistence?(): ChatMessage[];
     /**
      * The live `AgentConfig` currently active in the driver — the instance whose
      * `onActivate` ran, so its `serialize`/`getDebugSnapshot` closures hold live
@@ -1899,6 +1906,24 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
     getRawHistory(): readonly ChatMessage[];
     /** Returns the current fold stack names for debugging. */
     getActiveFoldNames(): string[];
+    /**
+     * The transcript as it should be **stored**: every tool payload the model has already stopped
+     * seeing replaced by the same stub it was sent (GENC-1566). Live history is untouched — this
+     * returns a copy.
+     *
+     * Condensation deliberately spares stored history, because the live transcript and the debug
+     * export both read it. A host writing that transcript to durable storage inherits the other
+     * half of that decision: it stores payloads the driver has already retired, on every autosave,
+     * for the life of the session. Measured on one small Create session — 58,187 chars, 7.4% of a
+     * 790 KB session object, across five payloads worth 14,434 tokens of context, written 86 times.
+     *
+     * Only already-collapsed payloads are touched, so this can never store a stub for something the
+     * model can still see, and it has no side effects (see `condenseForPersistence`, which is
+     * internal). A host that wants the unredacted transcript still calls
+     * {@link ChatDriver.getRawHistory}, and a diagnostics stream that keeps full payloads is
+     * unaffected — which is what makes the elision recoverable.
+     */
+    getHistoryForPersistence(): ChatMessage[];
     getSuggestions(history: ChatMessage[], prompt: string, count: number, allAgentInfo?: AllAgentSummary[]): Promise<string[]>;
     /**
      * Whether `compact()` would do anything right now — a summarizable run of older
@@ -4922,6 +4947,20 @@ export declare class OrchestratingDriver extends EventTarget implements AiDriver
     setFlowOwner(name: string | null): void;
     loadHistory(messages: ChatMessage[]): void;
     getRawHistory(): readonly ChatMessage[];
+    /**
+     * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it
+     * is the only object that knows which payloads the model has stopped seeing (GENC-1566).
+     *
+     * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares
+     * `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back
+     * to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it
+     * wraps one — so without an explicit forward the optional call resolves to `undefined` and every
+     * host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly
+     * that way on a Create run: 10 `context.condensed` events fired, and the session still stored
+     * the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the
+     * tests passed, and the feature did nothing.
+     */
+    getHistoryForPersistence(): ChatMessage[];
     /** {@inheritDoc AiDriver.setContextGuard} */
     setContextGuard(policy?: ContextGuardPolicy): void;
     /** {@inheritDoc AiDriver.compact} */

package/dist/chat-driver.cjs

@@ -3936,6 +3936,14 @@ function condenseStub(target, tool, trigger, origLen, restorable, imageCount2 =
   const images = imageCount2 > 0 ? ` + ${imageCount2} image${imageCount2 === 1 ? "" : "s"}` : "";
   return `[${tool}${key} \u2014 ${what} elided, ~${origLen} chars${images} (${triggerReason(trigger)})${restore}]`;
 }
+function renderCondensedArgs(policy, tool, fired, origLen) {
+  return {
+    [CONDENSED_ARGS_KEY]: policy === "drop" || policy === "pointer" ? condenseStub("args", tool, fired, origLen, policy === "pointer") : policy.replaceWith
+  };
+}
+function renderCondensedResult(policy, tool, fired, textLen, imageCount2) {
+  return policy === "drop" || policy === "pointer" ? condenseStub("response", tool, fired, textLen, policy === "pointer", imageCount2) : policy.replaceWith;
+}
 function triggerLabel(trigger) {
   switch (trigger.kind) {
     case "age":
@@ -4010,10 +4018,7 @@ function applyCondensation(history, policies, ctx, onCondensed) {
         const origLen = JSON.stringify(tc.args ?? {}).length;
         if (origLen < CONDENSE_MIN_CHARS) return tc;
         changed = true;
-        const result = entry.policy.args;
-        const args = {
-          [CONDENSED_ARGS_KEY]: result === "drop" || result === "pointer" ? condenseStub("args", tc.name, fired, origLen, result === "pointer") : result.replaceWith
-        };
+        const args = renderCondensedArgs(entry.policy.args, tc.name, fired, origLen);
         if (!entry.reportedArgs) {
           entry.reportedArgs = true;
           const stubLen = JSON.stringify(args).length;
@@ -4039,8 +4044,13 @@ function applyCondensation(history, policies, ctx, onCondensed) {
       const fired = entry?.policy.response ? firstFired(msg.toolResult.toolCallId, entry) : void 0;
       if (entry && fired && origLen >= CONDENSE_MIN_CHARS) {
         const tool = nameById.get(msg.toolResult.toolCallId) ?? msg.toolResult.toolCallId;
-        const result = entry.policy.response;
-        const content = result === "drop" || result === "pointer" ? condenseStub("response", tool, fired, textLen, result === "pointer", images.length) : result.replaceWith;
+        const content = renderCondensedResult(
+          entry.policy.response,
+          tool,
+          fired,
+          textLen,
+          images.length
+        );
         if (!entry.reportedResponse) {
           entry.reportedResponse = true;
           onCondensed({
@@ -4060,6 +4070,53 @@ function applyCondensation(history, policies, ctx, onCondensed) {
     return msg;
   });
 }
+function condenseForPersistence(history, policies) {
+  if (policies.size === 0) return history;
+  const nameById = /* @__PURE__ */ new Map();
+  for (const msg of history) {
+    for (const tc of msg.toolCalls ?? []) nameById.set(tc.id, tc.name);
+  }
+  let changed = false;
+  const projected = history.map((msg) => {
+    if (msg.toolCalls?.length) {
+      let callsChanged = false;
+      const toolCalls = msg.toolCalls.map((tc) => {
+        const entry = policies.get(tc.id);
+        if (!entry?.reportedArgs || !entry.firedTrigger || !entry.policy.args) return tc;
+        callsChanged = true;
+        const origLen = JSON.stringify(tc.args ?? {}).length;
+        return {
+          ...tc,
+          args: renderCondensedArgs(entry.policy.args, tc.name, entry.firedTrigger, origLen)
+        };
+      });
+      if (callsChanged) {
+        changed = true;
+        return { ...msg, toolCalls };
+      }
+      return msg;
+    }
+    if (msg.toolResult) {
+      const entry = policies.get(msg.toolResult.toolCallId);
+      if (entry?.reportedResponse && entry.firedTrigger && entry.policy.response) {
+        changed = true;
+        const tool = nameById.get(msg.toolResult.toolCallId) ?? msg.toolResult.toolCallId;
+        const images = msg.toolResult.attachments ?? [];
+        const content = renderCondensedResult(
+          entry.policy.response,
+          tool,
+          entry.firedTrigger,
+          msg.toolResult.content?.length ?? 0,
+          images.length
+        );
+        const { attachments: _elided, ...restOfResult } = msg.toolResult;
+        return { ...msg, toolResult: { ...restOfResult, content } };
+      }
+    }
+    return msg;
+  });
+  return changed ? projected : history;
+}
 
 // src/utils/history-transform.ts
 function maskToolPayload(msg) {
@@ -5101,6 +5158,26 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   getActiveFoldNames() {
     return this.foldStack.map((f) => f.foldName);
   }
+  /**
+   * The transcript as it should be **stored**: every tool payload the model has already stopped
+   * seeing replaced by the same stub it was sent (GENC-1566). Live history is untouched — this
+   * returns a copy.
+   *
+   * Condensation deliberately spares stored history, because the live transcript and the debug
+   * export both read it. A host writing that transcript to durable storage inherits the other
+   * half of that decision: it stores payloads the driver has already retired, on every autosave,
+   * for the life of the session. Measured on one small Create session — 58,187 chars, 7.4% of a
+   * 790 KB session object, across five payloads worth 14,434 tokens of context, written 86 times.
+   *
+   * Only already-collapsed payloads are touched, so this can never store a stub for something the
+   * model can still see, and it has no side effects (see `condenseForPersistence`, which is
+   * internal). A host that wants the unredacted transcript still calls
+   * {@link ChatDriver.getRawHistory}, and a diagnostics stream that keeps full payloads is
+   * unaffected — which is what makes the elision recoverable.
+   */
+  getHistoryForPersistence() {
+    return condenseForPersistence([...this.history], this.condensePolicies);
+  }
   async getSuggestions(history, prompt2, count, allAgentInfo) {
     const defaultProvider = this.providerRegistry.default();
     if (!defaultProvider.prompt) {
@@ -6924,6 +7001,22 @@ var OrchestratingDriver = class extends EventTarget {
   getRawHistory() {
     return this.chatDriver.getHistory();
   }
+  /**
+   * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it
+   * is the only object that knows which payloads the model has stopped seeing (GENC-1566).
+   *
+   * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares
+   * `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back
+   * to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it
+   * wraps one — so without an explicit forward the optional call resolves to `undefined` and every
+   * host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly
+   * that way on a Create run: 10 `context.condensed` events fired, and the session still stored
+   * the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the
+   * tests passed, and the feature did nothing.
+   */
+  getHistoryForPersistence() {
+    return this.chatDriver.getHistoryForPersistence();
+  }
   /** {@inheritDoc AiDriver.setContextGuard} */
   setContextGuard(policy) {
     this.chatDriver.setContextGuard(policy);