@kenkaiiii/gg-agent 5.49.3 → 5.49.5

package/dist/index.js

@@ -35,6 +35,60 @@ function isLocalBackendUrl(baseUrl) {
   return false;
 }
 
+// src/output-ceiling.ts
+var TTL_MS = 24 * 60 * 60 * 1e3;
+var MIN_PLAUSIBLE_CEILING = 256;
+var MAX_PLAUSIBLE_CEILING = 1e7;
+var ceilings = /* @__PURE__ */ new Map();
+function outputRouteKey(route) {
+  return `${route.provider}\0${route.baseUrl ?? "default"}\0${route.model}`;
+}
+function parseOutputTokenCeiling(err) {
+  if (!(err instanceof Error)) return null;
+  const msg = err.message;
+  if (!/max_tokens|max output tokens|output tokens|completion tokens/i.test(msg)) return null;
+  if (err.statusCode === 402) return null;
+  if (/credit|billing|payment|insufficient|balance|quota/i.test(msg)) return null;
+  const patterns = [
+    // Anthropic: "max_tokens: 100000 > 64000, which is the maximum allowed…"
+    /max_tokens:\s*\d+\s*>\s*(\d+)/i,
+    // OpenAI: "…this model supports at most 16384 completion tokens"
+    /(?:at most|maximum of|limit of)\s+([\d,_]+)\s*(?:output|completion)?\s*tokens/i,
+    // Generic: "max output tokens is 8192" / "max_tokens must be <= 4096"
+    /(?:max_tokens|max output tokens)\b[^\d]{0,30}?([\d,_]+)/i
+  ];
+  for (const pattern of patterns) {
+    const raw = msg.match(pattern)?.[1];
+    if (raw === void 0) continue;
+    const limit = Number(raw.replace(/[,_]/g, ""));
+    if (Number.isFinite(limit) && limit >= MIN_PLAUSIBLE_CEILING && limit <= MAX_PLAUSIBLE_CEILING) {
+      return limit;
+    }
+  }
+  return null;
+}
+function rememberOutputCeiling(key, limit) {
+  const known = outputTokenCeiling(key);
+  ceilings.set(key, {
+    limit: known === void 0 ? limit : Math.min(known, limit),
+    expiresAt: Date.now() + TTL_MS
+  });
+}
+function outputTokenCeiling(key) {
+  const entry = ceilings.get(key);
+  if (!entry) return void 0;
+  if (entry.expiresAt <= Date.now()) {
+    ceilings.delete(key);
+    return void 0;
+  }
+  return entry.limit;
+}
+function clampOutputTokens(key, requested) {
+  const ceiling = outputTokenCeiling(key);
+  if (ceiling === void 0) return requested;
+  return requested === void 0 ? ceiling : Math.min(requested, ceiling);
+}
+
 // src/agent-loop.ts
 var DEFAULT_MAX_TURNS = 300;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e5;
@@ -271,6 +325,16 @@ async function* agentLoop(messages, options) {
   const MAX_OUTPUT_CONTINUATIONS = 2;
   const MAX_TOKENS_CONTINUATION_PROMPT = "[Your previous response hit the output-token limit and was cut off. The text above is what was already delivered to the user. Continue exactly from where it stopped \u2014 do not repeat or restart it.]";
   let maxTokensContinuations = 0;
+  let providerCalls = 0;
+  let nonStreamingCalls = 0;
+  let warnedNonStreaming = false;
+  const MAX_OUTPUT_CEILING_RETRIES = 1;
+  let outputCeilingRetries = 0;
+  const ceilingKey = outputRouteKey({
+    provider: options.provider,
+    model: options.model,
+    baseUrl: options.baseUrl
+  });
   const OVERLOAD_BASE_DELAY_MS = 2e3;
   const OVERLOAD_MAX_DELAY_MS = 3e4;
   const STREAM_FIRST_EVENT_TIMEOUT_MS = 45e3;
@@ -398,6 +462,18 @@ async function* agentLoop(messages, options) {
       }, hardTimeoutMs);
       try {
         diag("stream_call", { nonStreaming: useNonStreamingFallback });
+        providerCalls++;
+        if (useNonStreamingFallback) nonStreamingCalls++;
+        if (!warnedNonStreaming && nonStreamingCalls >= 3) {
+          warnedNonStreaming = true;
+          diag("non_streaming_session", {
+            nonStreamingCalls,
+            providerCalls,
+            provider: options.provider,
+            model: options.model,
+            impact: "streaming is disabled for this session after repeated stalls: failed turns are re-billed in full instead of resuming from partial output, and replies appear only when complete"
+          });
+        }
         streamCallStart = Date.now();
         providerAttemptStartedAt = streamCallStart;
         let liveApiKey = options.apiKey;
@@ -423,7 +499,9 @@ async function* agentLoop(messages, options) {
           serverTools: options.serverTools,
           toolChoice: options.toolChoice,
           webSearch: options.webSearch,
-          maxTokens: options.maxTokens,
+          // Clamped to whatever ceiling this route has already rejected us for
+          // (identity when nothing has been learned).
+          maxTokens: clampOutputTokens(ceilingKey, options.maxTokens),
           temperature: options.temperature,
           thinking: options.thinking,
           apiKey: liveApiKey,
@@ -573,6 +651,29 @@ async function* agentLoop(messages, options) {
           });
           throw err;
         }
+        const statedCeiling = parseOutputTokenCeiling(err);
+        if (statedCeiling !== null) {
+          rememberOutputCeiling(ceilingKey, statedCeiling);
+          diag("output_ceiling_learned", {
+            ceiling: statedCeiling,
+            requested: options.maxTokens,
+            provider: options.provider,
+            model: options.model
+          });
+          if (outputCeilingRetries < MAX_OUTPUT_CEILING_RETRIES) {
+            outputCeilingRetries++;
+            yield {
+              type: "retry",
+              reason: "provider_error",
+              attempt: outputCeilingRetries,
+              maxAttempts: MAX_OUTPUT_CEILING_RETRIES,
+              delayMs: 0,
+              silent: true
+            };
+            turn--;
+            continue;
+          }
+        }
         if (isContextOverflow(err)) {
           const overflowDetails = extractContextOverflowDetails(err);
           diag("context_overflow_detected", {