@yeaft/webchat-agent 0.1.702 → 0.1.703

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.702",
+  "version": "0.1.703",
   "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 }}
  */

package/unify/llm/anthropic.js

@@ -14,9 +14,6 @@ import {
   LLMServerError,
   LLMAbortError,
   redactRawRequest,
-  capRawRequest,
-  capRawString,
-  RAW_PAYLOAD_CAP_BYTES,
 } from './adapter.js';
 import {
   normalizeEffort,
@@ -184,9 +181,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,7 +195,7 @@ 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({
@@ -207,8 +205,7 @@ export class AnthropicAdapter extends LLMAdapter {
               headers: response.headers && typeof response.headers.entries === 'function'
                 ? Object.fromEntries(response.headers.entries())
                 : {},
-              // task-344 follow-up (N2): cap error body.
-              body: capRawString(errorBody),
+              body: errorBody,
             },
           });
         } catch { /* ignore */ }
@@ -223,12 +220,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.
+    // Accumulate raw SSE body verbatim for the debug panel. No truncation:
+    // a truncated copy of the response is misleading. If the resulting
+    // payload is too large for the debug store the bound is per-LOOP-COUNT
+    // on the client (see web/stores/chat.js MAX_UNIFY_DEBUG_LOOPS), not
+    // per-payload mutilation here.
     let rawSseBody = '';
-    let rawSseTotalBytes = 0;
-    let rawSseCapped = false;
     const responseHeaders = response.headers && typeof response.headers.entries === 'function'
       ? Object.fromEntries(response.headers.entries())
       : {};
@@ -241,20 +238,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;
-          }
-        }
+        rawSseBody += chunkText;
         const lines = buffer.split('\n');
         buffer = lines.pop() || ''; // Keep incomplete line
 
@@ -344,19 +328,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: rawSseBody,
               format: 'sse',
             },
           });