@yeaft/webchat-agent 0.1.702 → 0.1.704

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.702",
+  "version": "0.1.704",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/engine.js

@@ -74,10 +74,11 @@ const MAX_CONTINUE_TURNS = 3;
  *   - `toolCalls` on assistant turns (the LLM's function_call requests)
  *   - `toolCallId` + `isError` on tool turns (the paired tool_result)
  *
- * Content is truncated at 50000 chars; each tool_call input is JSON-stringified
- * + sliced at 10000 chars before being re-parsed, so a runaway `input` blob
- * can't blow past the WebSocket frame budget. Unknown roles pass through
- * unchanged.
+ * Content is passed through verbatim — never truncated. Debug traces must
+ * mirror exactly what we sent to the LLM; a truncated copy is misleading.
+ * If the resulting payload is too large for the client debug store the
+ * bound is per-loop-count (see `MAX_UNIFY_DEBUG_LOOPS` in
+ * `web/stores/chat.js`), not per-payload mutilation here.
  *
  * Pure function — no side effects on the input message.
  *
@@ -86,22 +87,13 @@ const MAX_CONTINUE_TURNS = 3;
  */
 export function mapDebugMessage(m) {
   const out = { role: m.role };
-  out.content = typeof m.content === 'string' ? m.content.slice(0, 50000) : m.content;
+  out.content = m.content;
   if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
-    out.toolCalls = m.toolCalls.map(tc => {
-      let input = tc.input;
-      try {
-        const s = JSON.stringify(input);
-        if (typeof s === 'string' && s.length > 10000) {
-          input = { __truncated: true, preview: s.slice(0, 10000) };
-        }
-      } catch {
-        // Non-serializable input — fall through with raw reference; the
-        // frontend's JSON.stringify will hit the same failure and replace
-        // it with a placeholder string.
-      }
-      return { id: tc.id, name: tc.name, input };
-    });
+    out.toolCalls = m.toolCalls.map(tc => ({
+      id: tc.id,
+      name: tc.name,
+      input: tc.input,
+    }));
   }
   if (m.toolCallId) out.toolCallId = m.toolCallId;
   if (m.isError != null) out.isError = m.isError;

package/unify/llm/adapter.js

@@ -105,65 +105,20 @@ export class LLMAbortError extends Error {
   }
 }
 
-// ─── task-344: Raw payload redaction helper ────────────────────
-
-/**
- * task-344 follow-up (N2): cap raw payload size exposed via onRawExchange.
- * Prevents the web debug store from linear-growing when a single turn
- * sends / receives megabytes of content. 256 KiB per field per turn.
- */
-export const RAW_PAYLOAD_CAP_BYTES = 256 * 1024;
-
-/**
- * Truncate a string to at most `cap` bytes (UTF-8). When within cap the
- * original is returned; otherwise a prefix with a trailing
- * `…[truncated, original N bytes]` marker. Non-string inputs pass through.
- *
- * @param {string} s
- * @param {number} [cap=RAW_PAYLOAD_CAP_BYTES]
- * @returns {string}
- */
-export function capRawString(s, cap = RAW_PAYLOAD_CAP_BYTES) {
-  if (typeof s !== 'string') return s;
-  const encoder = new TextEncoder();
-  const fullBytes = encoder.encode(s);
-  if (fullBytes.length <= cap) return s;
-  const decoder = new TextDecoder('utf-8', { fatal: false });
-  const prefix = decoder.decode(fullBytes.slice(0, cap));
-  return `${prefix}…[truncated, original ${fullBytes.length} bytes]`;
-}
-
-/**
- * Cap the `body` field of a rawRequest envelope. JSON-stringifies objects
- * before sizing so an oversized `messages` array does not escape the cap.
- * When truncation fires, body becomes a string (JSON prefix + marker);
- * objects under cap stay objects.
- *
- * @param {{ url: string, method: string, headers: object, body: any }} req
- * @param {number} [cap=RAW_PAYLOAD_CAP_BYTES]
- * @returns {{ url: string, method: string, headers: object, body: any }}
- */
-export function capRawRequest(req, cap = RAW_PAYLOAD_CAP_BYTES) {
-  if (!req || typeof req !== 'object') return req;
-  let body = req.body;
-  if (body != null && typeof body !== 'string') {
-    let serialized;
-    try { serialized = JSON.stringify(body); }
-    catch { serialized = String(body); }
-    if (typeof serialized === 'string' && new TextEncoder().encode(serialized).length > cap) {
-      body = capRawString(serialized, cap);
-    }
-  } else if (typeof body === 'string') {
-    body = capRawString(body, cap);
-  }
-  return { url: req.url, method: req.method, headers: req.headers, body };
-}
+// ─── Raw payload redaction helper ──────────────────────────────
 
 /**
  * Redact sensitive headers (API keys / bearer tokens) from a raw request
  * shape before exposing it to debug UI. Always returns a NEW object — never
  * mutates the input.
  *
+ * NOTE: there is intentionally NO body / response truncation here. The whole
+ * point of the "copy request" debug feature is to capture EXACTLY what we
+ * sent to the LLM. A truncated copy is worse than useless — it lies about
+ * what the model saw. If the resulting payload is too large for the debug
+ * store, the fix is to bound retention (drop oldest turns), not to mutilate
+ * individual payloads. See `MAX_UNIFY_DEBUG_LOOPS` in `web/stores/chat.js`.
+ *
  * @param {{ url: string, method: string, headers: object, body: any }} req
  * @returns {{ url: string, method: string, headers: object, body: any }}
  */
@@ -180,6 +135,27 @@ export function redactRawRequest(req) {
   return { url: req.url, method: req.method, headers, body: req.body };
 }
 
+/**
+ * Snapshot a Fetch Response's headers into a plain object for the debug
+ * panel. Defensive against polyfilled / mocked Response shapes that don't
+ * implement `Headers#entries()` — falls back to `{}` rather than throwing.
+ *
+ * NOTE: multi-valued headers (e.g. `Set-Cookie`) collapse to the last value
+ * because `Object.fromEntries` can't represent duplicates. For LLM debug
+ * traffic this is fine; if a future use case needs multi-valued capture,
+ * switch the return to an array of [k, v] pairs.
+ *
+ * @param {Response | { headers?: { entries?: () => Iterable<[string, string]> } }} response
+ * @returns {Record<string, string>}
+ */
+export function safeHeaders(response) {
+  const h = response && response.headers;
+  if (h && typeof h.entries === 'function') {
+    return Object.fromEntries(h.entries());
+  }
+  return {};
+}
+
 // ─── Base Class ────────────────────────────────────────────────
 
 /**

package/unify/llm/anthropic.js

@@ -14,9 +14,7 @@ import {
   LLMServerError,
   LLMAbortError,
   redactRawRequest,
-  capRawRequest,
-  capRawString,
-  RAW_PAYLOAD_CAP_BYTES,
+  safeHeaders,
 } from './adapter.js';
 import {
   normalizeEffort,
@@ -184,9 +182,10 @@ export class AnthropicAdapter extends LLMAdapter {
       'anthropic-version': API_VERSION,
     };
 
-    // task-344: expose raw request (redacted) for debug panel.
-    // task-344 follow-up (N2): cap body to RAW_PAYLOAD_CAP_BYTES.
-    const rawRequest = capRawRequest(redactRawRequest({ url, method: 'POST', headers, body }));
+    // Expose the raw request (auth-redacted) for the debug panel. The body
+    // is captured verbatim — never truncated — so "copy request" matches
+    // exactly what we POST to the LLM.
+    const rawRequest = redactRawRequest({ url, method: 'POST', headers, body });
 
     const response = await fetch(url, {
       method: 'POST',
@@ -197,18 +196,15 @@ export class AnthropicAdapter extends LLMAdapter {
 
     if (!response.ok) {
       const errorBody = await response.text();
-      // task-344: capture error response too, then throw.
+      // Capture error response too, then throw.
       if (onRawExchange) {
         try {
           onRawExchange({
             rawRequest,
             rawResponse: {
               status: response.status,
-              headers: response.headers && typeof response.headers.entries === 'function'
-                ? Object.fromEntries(response.headers.entries())
-                : {},
-              // task-344 follow-up (N2): cap error body.
-              body: capRawString(errorBody),
+              headers: safeHeaders(response),
+              body: errorBody,
             },
           });
         } catch { /* ignore */ }
@@ -223,15 +219,12 @@ export class AnthropicAdapter extends LLMAdapter {
     let currentToolCallId = null;
     let currentToolName = null;
     let currentToolInput = '';
-    // task-344: accumulate raw SSE body for debug exposure.
-    // task-344 follow-up (N2): cap growth — once past RAW_PAYLOAD_CAP_BYTES
-    // we freeze the captured body and record total-bytes-seen separately.
-    let rawSseBody = '';
-    let rawSseTotalBytes = 0;
-    let rawSseCapped = false;
-    const responseHeaders = response.headers && typeof response.headers.entries === 'function'
-      ? Object.fromEntries(response.headers.entries())
-      : {};
+    // Accumulate raw SSE body verbatim for the debug panel. No truncation:
+    // see `redactRawRequest` in adapter.js for the verbatim-design rationale.
+    // Push-then-join keeps allocation bounded for multi-MiB payloads (avoids
+    // O(n²) string concat).
+    const rawSseBodyChunks = [];
+    const responseHeaders = safeHeaders(response);
     const responseStatus = response.status;
 
     try {
@@ -241,20 +234,7 @@ export class AnthropicAdapter extends LLMAdapter {
 
         const chunkText = decoder.decode(value, { stream: true });
         buffer += chunkText;
-        // task-344 follow-up (N2): size-capped capture.
-        rawSseTotalBytes += value.byteLength;
-        if (!rawSseCapped) {
-          if (rawSseTotalBytes <= RAW_PAYLOAD_CAP_BYTES) {
-            rawSseBody += chunkText;
-          } else {
-            // Append enough of this chunk to meet the cap, then freeze.
-            const remaining = RAW_PAYLOAD_CAP_BYTES - (rawSseTotalBytes - value.byteLength);
-            if (remaining > 0) {
-              rawSseBody += chunkText.slice(0, remaining);
-            }
-            rawSseCapped = true;
-          }
-        }
+        rawSseBodyChunks.push(chunkText);
         const lines = buffer.split('\n');
         buffer = lines.pop() || ''; // Keep incomplete line
 
@@ -344,19 +324,16 @@ export class AnthropicAdapter extends LLMAdapter {
       }
     } finally {
       reader.releaseLock();
-      // task-344: emit raw exchange after stream completes (or errors).
+      // Emit raw exchange after stream completes (or errors). Body is the
+      // verbatim SSE — never truncated.
       if (onRawExchange) {
         try {
-          // task-344 follow-up (N2): append truncation marker when capped.
-          const finalBody = rawSseCapped
-            ? `${rawSseBody}…[truncated, original ${rawSseTotalBytes} bytes]`
-            : rawSseBody;
           onRawExchange({
             rawRequest,
             rawResponse: {
               status: responseStatus,
               headers: responseHeaders,
-              body: finalBody,
+              body: rawSseBodyChunks.join(''),
               format: 'sse',
             },
           });

package/unify/llm/openai-responses.js

@@ -32,6 +32,8 @@ import {
   LLMContextError,
   LLMServerError,
   LLMAbortError,
+  redactRawRequest,
+  safeHeaders,
 } from './adapter.js';
 import {
   normalizeEffort,
@@ -225,9 +227,16 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
   // ─── Streaming ──────────────────────────────────────────
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', extraBody?: object, signal?: AbortSignal }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', extraBody?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
+   *
+   * NOTE on `extraBody`: any keys you spread here are merged verbatim into
+   * the wire body and — because the verbatim debug feature is intentionally
+   * non-truncating — will surface in the debug panel via `rawRequest.body`.
+   * Do NOT put secrets in `extraBody`. Only `Authorization` / `x-api-key` /
+   * `api-key` headers are auto-redacted (see `redactRawRequest` in
+   * `adapter.js`); request-body fields are caller-controlled.
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal, onRawExchange }) {
     if (signal?.aborted) throw new LLMAbortError();
 
     const body = {
@@ -255,14 +264,21 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
     if (extraBody) Object.assign(body, extraBody);
 
+    const url = `${this.#baseUrl}/responses`;
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this.#apiKey}`,
+    };
+
+    // Expose the raw request (auth-redacted) for the debug panel. See
+    // `redactRawRequest` in adapter.js for the verbatim-design rationale.
+    const rawRequest = redactRawRequest({ url, method: 'POST', headers, body });
+
     let response;
     try {
-      response = await fetch(`${this.#baseUrl}/responses`, {
+      response = await fetch(url, {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.#apiKey}`,
-        },
+        headers,
         body: JSON.stringify(body),
         signal,
       });
@@ -273,6 +289,19 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
     if (!response.ok) {
       const errorBody = await response.text();
+      // Capture error response too, then throw. Parity with anthropic.js.
+      if (onRawExchange) {
+        try {
+          onRawExchange({
+            rawRequest,
+            rawResponse: {
+              status: response.status,
+              headers: safeHeaders(response),
+              body: errorBody,
+            },
+          });
+        } catch { /* ignore */ }
+      }
       throw this.#classifyError(response.status, errorBody);
     }
 
@@ -287,11 +316,21 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     const emittedToolCallIds = new Set();
     let sawToolCall = false;
 
+    // Accumulate raw SSE body verbatim for the debug panel. No truncation:
+    // see `redactRawRequest` in adapter.js for the verbatim-design rationale.
+    // Push-then-join keeps allocation bounded for multi-MiB payloads (avoids
+    // O(n²) string concat).
+    const rawSseBodyChunks = [];
+    const responseHeaders = safeHeaders(response);
+    const responseStatus = response.status;
+
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        buffer += decoder.decode(value, { stream: true });
+        const chunkText = decoder.decode(value, { stream: true });
+        buffer += chunkText;
+        rawSseBodyChunks.push(chunkText);
 
         // SSE events are separated by blank lines; split on \n
         const lines = buffer.split('\n');
@@ -409,11 +448,33 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       throw err;
     } finally {
       try { reader.releaseLock(); } catch { /* noop */ }
+      // Emit raw exchange after stream completes (or errors). Body is the
+      // verbatim SSE — never truncated. Parity with anthropic.js.
+      if (onRawExchange) {
+        try {
+          onRawExchange({
+            rawRequest,
+            rawResponse: {
+              status: responseStatus,
+              headers: responseHeaders,
+              body: rawSseBodyChunks.join(''),
+              format: 'sse',
+            },
+          });
+        } catch { /* ignore */ }
+      }
     }
   }
 
   // ─── Non-streaming call() ───────────────────────────────
 
+  /**
+   * Side-query (consolidate / dream / recall / light) entry point. Does
+   * NOT accept `onRawExchange` — these calls intentionally don't surface
+   * in the user-facing debug panel. If a future product change wants to
+   * expose them, mirror the stream() instrumentation. Parity with
+   * anthropic.js's `call()`.
+   */
   async call({ model, system, messages, maxTokens = 4096, effort, extraBody, signal }) {
     if (signal?.aborted) throw new LLMAbortError();