@yeaft/webchat-agent 1.0.411 → 1.0.412

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.411"}
+{"version":"1.0.412"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.411",
+  "version": "1.0.412",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/engine.js

@@ -22,7 +22,7 @@ import { promises as fsp } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { getRuntimePlatformInfo } from './runtime-platform.js';
-import { LLMContextError, LLMAbortError, LLMAuthError, LLMRateLimitError, LLMServerError, LLMStreamIdleTimeoutError } from './llm/adapter.js';
+import { LLMContextError, LLMAbortError, LLMAuthError, LLMPolicyError, LLMRateLimitError, LLMServerError, LLMStreamIdleTimeoutError } from './llm/adapter.js';
 import { runMemoryPreflow, buildRelevantScopes, memoryScopeLabel } from './sessions/pre-flow.js';
 import {
   readProjectDoc,
@@ -155,6 +155,8 @@ const RETRY_DEFAULTS = Object.freeze({
 
 const RETRY_CONTINUATION_PROMPT =
   'Continue from the exact point where the previous response stopped. Do not repeat text already produced.';
+const POLICY_RECOVERY_PROMPT =
+  'Continue this authorized code review, but describe security findings abstractly. Do not repeat credential-like or exploit payloads, secrets, tokens, or step-by-step misuse instructions. Preserve the technical conclusion, evidence location, severity, and remediation.';
 
 // Accept legacy namespaced commands and Claude Code-style bare skill commands.
 // Project-tier skills are shown as /<skill-name>; /yeaft-skills:<name> and
@@ -2791,6 +2793,7 @@ export class Engine {
     let retryPolicy = resolveRetryPolicy(this.#config);
     let consecutiveRetryableErrors = 0;
     let consecutiveForbiddenErrors = 0;
+    let contentPolicyRecoveryAttempts = 0;
 
     while (true) {
       turnNumber++;
@@ -3442,17 +3445,42 @@ export class Engine {
             errorName: err?.name || null,
             statusCode: err?.statusCode ?? null,
             retryable: err instanceof LLMRateLimitError || err instanceof LLMServerError,
+            reasonCode: err?.reasonCode || null,
             message: String(err?.message || '').slice(0, 200),
           },
         });
 
         const earlyIsRateLimit = err instanceof LLMRateLimitError;
         const earlyIsTransient = err instanceof LLMServerError;
+        const earlyIsContentPolicy = err instanceof LLMPolicyError;
         // A completed tool_call has already crossed the streaming boundary to
         // the caller. Replaying that request would publish a duplicate call and
         // leave ambiguous execution ownership, so only pre-tool failures are
         // eligible for transparent retry or model fallback.
         const canReplayProviderRequest = toolCalls.length === 0;
+        if (earlyIsContentPolicy && canReplayProviderRequest && contentPolicyRecoveryAttempts === 0) {
+          contentPolicyRecoveryAttempts = 1;
+          endAttemptTrace('llm_retry');
+          if (responseText) prepareRetryContinuation();
+          retryLifecycle.pendingContinuation = {
+            role: 'user',
+            content: POLICY_RECOVERY_PROMPT,
+            userAuthored: false,
+          };
+          yield {
+            type: 'llm_retry',
+            attempt: 1,
+            maxRetries: 1,
+            delayMs: 0,
+            reason: 'content_policy_recovery',
+            recoveryMode: 'continue',
+            errorName: err.name,
+            statusCode: err.statusCode ?? 422,
+            message: 'Provider content-safety rejection; retrying once with sensitive examples abstracted.',
+          };
+          yield { type: 'turn_end', turnNumber, stopReason: 'llm_retry', threadId };
+          continue;
+        }
         const earlyIsTemporaryForbidden = err instanceof LLMAuthError
           && err.statusCode === 403
           && err.temporary === true;
@@ -3640,9 +3668,25 @@ export class Engine {
             && consecutiveRetryableErrors >= retryPolicy.maxRetries;
           errorEvent.retryAttempts = consecutiveRetryableErrors;
           errorEvent.maxRetries = retryPolicy.maxRetries;
+        } else if (err instanceof LLMPolicyError) {
+          errorEvent.reason = 'content_policy_denied';
+          errorEvent.retryExhausted = contentPolicyRecoveryAttempts >= 1;
+          errorEvent.retryAttempts = contentPolicyRecoveryAttempts;
+          errorEvent.maxRetries = 1;
         }
         yield errorEvent;
-        yield { type: 'turn_end', turnNumber, stopReason: 'error', threadId, terminal: true };
+        yield {
+          type: 'turn_end',
+          turnNumber,
+          stopReason: 'error',
+          threadId,
+          terminal: true,
+          detail: {
+            errorName: err?.name || 'Error',
+            statusCode: err?.statusCode ?? null,
+            reason: errorEvent.reason || err?.reasonCode || null,
+          },
+        };
         break;
       }
 

package/yeaft/llm/adapter.js

@@ -140,6 +140,29 @@ export function classifyAuthError(statusCode, responseBody = '', details = {}) {
   });
 }
 
+/** Provider content-safety rejection (commonly 422) — eligible for one sanitized recovery. */
+export class LLMPolicyError extends Error {
+  constructor(_providerMessage, statusCode = 422, details = {}) {
+    super('The LLM provider blocked this request under its content-safety policy. Continue and avoid repeating sensitive payloads or credential-like examples.');
+    this.name = 'LLMPolicyError';
+    this.statusCode = statusCode;
+    this.reasonCode = 'content_policy_denied';
+    this.provider = details.provider || null;
+    this.model = details.model || null;
+  }
+}
+
+const CONTENT_POLICY_RE = /(?:content (?:was )?flagged|content[-_ ]?safety|cybersecurity risk|safety policy|safety system|content[_ -]?filter|policy[_ -]?violation)/i;
+
+export function classifyPolicyError(statusCode, responseBody = '', details = {}) {
+  const status = Number(statusCode) || 0;
+  const signals = providerErrorSignals(responseBody);
+  if (status !== 422 || (!CONTENT_POLICY_RE.test(signals.code) && !CONTENT_POLICY_RE.test(signals.message))) {
+    return null;
+  }
+  return new LLMPolicyError(signals.message, status, details);
+}
+
 /** Context too long error (413 or API-specific) — need compaction. */
 export class LLMContextError extends Error {
   constructor(message) {

package/yeaft/llm/anthropic.js

@@ -13,6 +13,7 @@ import {
   retryAfterFromResponse,
   LLMAuthError,
   classifyAuthError,
+  classifyPolicyError,
   LLMContextError,
   LLMServerError,
   LLMAbortError,
@@ -230,6 +231,8 @@ export class AnthropicAdapter extends LLMAdapter {
       const retryAfter = retryAfterFromResponse(response);
       return new LLMRateLimitError(`Anthropic overloaded (${authHint}): ${body}`, status, retryAfter);
     }
+    const policyError = classifyPolicyError(status, body);
+    if (policyError) return policyError;
     if (body.includes('prompt is too long') || body.includes('max_tokens')) {
       return new LLMContextError(`Anthropic context error (${authHint}): ${body}`);
     }

package/yeaft/llm/openai-responses.js

@@ -30,6 +30,7 @@ import {
   LLMRateLimitError,
   LLMAuthError,
   classifyAuthError,
+  classifyPolicyError,
   LLMContextError,
   LLMServerError,
   LLMAbortError,
@@ -219,6 +220,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       const retryAfter = retryAfterFromResponse(response);
       return new LLMRateLimitError(`Overloaded: ${body}`, status, retryAfter);
     }
+    const policyError = classifyPolicyError(status, body);
+    if (policyError) return policyError;
     if (status === 413 || body.includes('context_length_exceeded') || body.includes('maximum context length')) {
       return new LLMContextError(`Context too long: ${body}`);
     }

package/yeaft/web-bridge.js

@@ -4464,9 +4464,13 @@ function handleEngineEvent(event, hctx) {
       const errMsg = event.error?.message || 'Unknown error';
       const retryAttempts = Number.isFinite(event.retryAttempts) ? event.retryAttempts : 0;
       const exhaustedIdle = event.reason === 'stream_idle_timeout' && event.retryExhausted;
-      const visibleErrMsg = exhaustedIdle && retryAttempts > 0
-        ? `${errMsg} after ${retryAttempts} fresh request retries`
-        : errMsg;
+      const contentPolicyDenied = event.reason === 'content_policy_denied'
+        || event.error?.reasonCode === 'content_policy_denied';
+      const visibleErrMsg = contentPolicyDenied
+        ? 'Provider blocked this request for content-safety reasons after one safe recovery attempt. Continue and ask the VP to avoid repeating sensitive payloads, credentials, tokens, or exploit samples.'
+        : exhaustedIdle && retryAttempts > 0
+          ? `${errMsg} after ${retryAttempts} fresh request retries`
+          : errMsg;
       hctx.lastEngineErrorDetail = {
         message: visibleErrMsg,
         ...(event.reason ? { reason: event.reason } : {}),