@kenkaiiii/gg-agent 5.67.1 → 5.68.1

package/dist/index.cjs

@@ -22,7 +22,12 @@ var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
   AgentStream: () => AgentStream,
+  DEFAULT_STREAM_RULE_MAX_RETRIES: () => DEFAULT_STREAM_RULE_MAX_RETRIES,
+  DEFAULT_STREAM_RULE_WINDOW_CHARS: () => DEFAULT_STREAM_RULE_WINDOW_CHARS,
+  JsonEscapeDecoder: () => JsonEscapeDecoder,
+  StreamRuleMonitor: () => StreamRuleMonitor,
   agentLoop: () => agentLoop,
+  buildStreamRuleReminder: () => buildStreamRuleReminder,
   cancelledBeforeStartText: () => cancelledBeforeStartText,
   indeterminateOutcomeText: () => indeterminateOutcomeText,
   isAbortError: () => isAbortError,
@@ -30,6 +35,7 @@ __export(index_exports, {
   isContextOverflow: () => isContextOverflow,
   isLocalBackendUrl: () => isLocalBackendUrl,
   isUsageLimitError: () => isUsageLimitError,
+  repairToolPairingAdjacent: () => repairToolPairingAdjacent,
   setStreamDiagnostic: () => setStreamDiagnostic
 });
 module.exports = __toCommonJS(index_exports);
@@ -117,6 +123,133 @@ function clampOutputTokens(key, requested) {
   return requested === void 0 ? ceiling : Math.min(requested, ceiling);
 }
 
+// src/stream-rules.ts
+var DEFAULT_STREAM_RULE_MAX_RETRIES = 3;
+var DEFAULT_STREAM_RULE_WINDOW_CHARS = 1024;
+var JSON_ESCAPES = {
+  n: "\n",
+  r: "\r",
+  t: "	",
+  b: "\b",
+  f: "\f",
+  '"': '"',
+  "\\": "\\",
+  "/": "/"
+};
+var JsonEscapeDecoder = class {
+  pending = "";
+  push(chunk) {
+    const input = this.pending + chunk;
+    this.pending = "";
+    if (!input.includes("\\")) return input;
+    let out = "";
+    let i = 0;
+    while (i < input.length) {
+      const ch = input.charAt(i);
+      if (ch !== "\\") {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (i + 1 >= input.length) {
+        this.pending = input.slice(i);
+        break;
+      }
+      const next = input.charAt(i + 1);
+      if (next === "u") {
+        if (i + 6 > input.length) {
+          this.pending = input.slice(i);
+          break;
+        }
+        const hex = input.slice(i + 2, i + 6);
+        out += /^[0-9a-fA-F]{4}$/.test(hex) ? String.fromCharCode(Number.parseInt(hex, 16)) : input.slice(i, i + 6);
+        i += 6;
+        continue;
+      }
+      out += JSON_ESCAPES[next] ?? next;
+      i += 2;
+    }
+    return out;
+  }
+};
+var StreamRuleMonitor = class {
+  maxRetries;
+  rules;
+  windowChars;
+  fired = /* @__PURE__ */ new Set();
+  retries = 0;
+  textWindow = "";
+  toolStreams = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.rules = config.rules;
+    this.maxRetries = Math.max(0, config.maxRetries ?? DEFAULT_STREAM_RULE_MAX_RETRIES);
+    this.windowChars = Math.max(64, config.windowChars ?? DEFAULT_STREAM_RULE_WINDOW_CHARS);
+  }
+  /** False once the retry cap is spent or every rule has fired — skip all matching. */
+  get active() {
+    return this.retries < this.maxRetries && this.fired.size < this.rules.length;
+  }
+  get retriesUsed() {
+    return this.retries;
+  }
+  beginAttempt() {
+    this.textWindow = "";
+    this.toolStreams.clear();
+  }
+  checkText(delta) {
+    if (!this.active || !delta) return null;
+    const scan = this.textWindow + delta;
+    this.textWindow = scan.slice(-this.windowChars);
+    const rules = this.match(scan, "text");
+    return rules.length > 0 ? { rules, source: "text" } : null;
+  }
+  checkToolArgs(id, toolName, argsDelta) {
+    if (!this.active || !argsDelta) return null;
+    let state = this.toolStreams.get(id);
+    if (!state) {
+      state = { window: "", decoder: new JsonEscapeDecoder() };
+      this.toolStreams.set(id, state);
+    }
+    const scan = state.window + state.decoder.push(argsDelta);
+    state.window = scan.slice(-this.windowChars);
+    const rules = this.match(scan, "tool", toolName);
+    return rules.length > 0 ? { rules, source: "tool", toolName } : null;
+  }
+  /** Consume one retry and mark the rules fired. Returns the retry ordinal (1-based). */
+  recordTrigger(rules) {
+    for (const rule of rules) this.fired.add(rule.name);
+    this.retries++;
+    return this.retries;
+  }
+  match(scan, source, toolName) {
+    const hits = [];
+    for (const rule of this.rules) {
+      if (this.fired.has(rule.name)) continue;
+      if (rule.scope !== "both" && rule.scope !== source) continue;
+      if (source === "tool" && rule.tools && toolName !== void 0) {
+        if (!rule.tools.includes(toolName)) continue;
+      }
+      rule.pattern.lastIndex = 0;
+      if (rule.pattern.test(scan)) hits.push(rule);
+    }
+    return hits;
+  }
+};
+function buildStreamRuleReminder(rules) {
+  const blocks = rules.map(
+    (rule) => `<system-reminder reason="stream_rule" rule="${rule.name.replace(/"/g, "'")}">
+Your previous response was interrupted mid-stream because it violated this rule. The interrupted output was discarded: the user never saw it and no tool call from it ran. Regenerate the response from the start and follow the rule:
+
+${rule.reminder.trim()}
+</system-reminder>`
+  );
+  return {
+    role: "user",
+    content: blocks.join("\n\n"),
+    provenance: { source: "runtime", kind: "notification", visibility: "hidden" }
+  };
+}
+
 // src/agent-loop.ts
 var DEFAULT_MAX_TURNS = 300;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e5;
@@ -382,6 +515,7 @@ async function* agentLoop(messages, options) {
   let runawayToolcallRetries = 0;
   let overflowCompactionAttempts = 0;
   let toolResultTruncationAttempted = false;
+  const streamRuleMonitor = options.streamRules && options.streamRules.rules.length > 0 ? new StreamRuleMonitor(options.streamRules) : null;
   const invalidToolArgumentCounts = /* @__PURE__ */ new Map();
   let toolArgumentAutoContinueUsed = false;
   let useNonStreamingFallback = false;
@@ -435,16 +569,7 @@ async function* agentLoop(messages, options) {
       turn++;
       if (logicalTurnStartedAt === 0) logicalTurnStartedAt = Date.now();
       toolMap = new Map((options.tools ?? []).map((t) => [t.name, t]));
-      let msgChars = 0;
-      for (const m of messages) {
-        if (typeof m.content === "string") msgChars += m.content.length;
-        else if (Array.isArray(m.content)) {
-          for (const p of m.content) {
-            if ("text" in p && typeof p.text === "string") msgChars += p.text.length;
-            if ("content" in p && typeof p.content === "string") msgChars += p.content.length;
-          }
-        }
-      }
+      const msgChars = countMessageChars(messages);
       let firstEventTimeoutMs;
       let initialHardTimeoutMs;
       if (baseFirstEventTimeoutMs === STREAM_FIRST_EVENT_TIMEOUT_MS) {
@@ -514,6 +639,9 @@ async function* agentLoop(messages, options) {
       let toolcallDeltaCount = 0;
       let runawayDetected = null;
       let attemptText = "";
+      let streamRuleHit = null;
+      let attemptThinkingChars = 0;
+      streamRuleMonitor?.beginAttempt();
       let lastYieldEndTime = Date.now();
       let maxConsumerLagMs = 0;
       const forwardAbort = () => streamController.abort();
@@ -599,6 +727,7 @@ async function* agentLoop(messages, options) {
           transportSessionId: options.transportSessionId,
           projectId: liveProjectId,
           cacheRetention: options.cacheRetention,
+          onContextPrepared: options.onContextPrepared,
           promptCacheKey: options.promptCacheKey,
           serviceTier: options.serviceTier,
           supportsImages: options.supportsImages,
@@ -672,8 +801,14 @@ async function* agentLoop(messages, options) {
           }
           if (event.type === "text_delta") {
             attemptText += event.text;
+            streamRuleHit = streamRuleMonitor?.checkText(event.text) ?? null;
+            if (streamRuleHit) {
+              streamController.abort();
+              break;
+            }
             yield { type: "text_delta", text: event.text };
           } else if (event.type === "thinking_delta") {
+            attemptThinkingChars += event.text.length;
             yield { type: "thinking_delta", text: event.text };
           } else if (event.type === "server_toolcall") {
             yield {
@@ -693,6 +828,11 @@ async function* agentLoop(messages, options) {
             const chunkChars = event.argsJson?.length ?? 0;
             toolcallDeltaChars += chunkChars;
             toolcallDeltaCount++;
+            streamRuleHit = streamRuleMonitor?.checkToolArgs(event.id, event.name, event.argsJson ?? "") ?? null;
+            if (streamRuleHit) {
+              streamController.abort();
+              break;
+            }
             if (!runawayDetected && (toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS || toolcallDeltaCount > MAX_TOOLCALL_DELTA_EVENTS)) {
               runawayDetected = {
                 kind: toolcallDeltaChars > MAX_TOOLCALL_DELTA_CHARS ? "chars" : "events",
@@ -714,6 +854,54 @@ async function* agentLoop(messages, options) {
           lastYieldEndTime = Date.now();
           resetIdleTimer();
         }
+        if (streamRuleHit && streamRuleMonitor) {
+          const attempt = streamRuleMonitor.recordTrigger(streamRuleHit.rules);
+          const ruleNames = streamRuleHit.rules.map((rule) => rule.name);
+          const priorPrompt = latestProviderUsage ? latestProviderUsage.inputTokens + (latestProviderUsage.cacheRead ?? 0) + (latestProviderUsage.cacheWrite ?? 0) : 0;
+          const newChars = priorPrompt > 0 && usageAnchorIndex !== void 0 ? countMessageChars(messages.slice(usageAnchorIndex + 1)) : msgChars;
+          const abortedUsage = {
+            inputTokens: Math.ceil(newChars / 4),
+            outputTokens: Math.ceil(
+              (attemptText.length + attemptThinkingChars + toolcallDeltaChars) / 4
+            ),
+            ...priorPrompt > 0 ? { cacheRead: priorPrompt } : {}
+          };
+          totalUsage.inputTokens += abortedUsage.inputTokens;
+          totalUsage.outputTokens += abortedUsage.outputTokens;
+          if (abortedUsage.cacheRead) {
+            totalUsage.cacheRead = (totalUsage.cacheRead ?? 0) + abortedUsage.cacheRead;
+          }
+          diag("stream_rule_triggered", {
+            rules: ruleNames.join(","),
+            source: streamRuleHit.source,
+            toolName: streamRuleHit.toolName,
+            attempt,
+            maxAttempts: streamRuleMonitor.maxRetries,
+            discardedChars: attemptText.length + toolcallDeltaChars,
+            provider: options.provider,
+            model: options.model
+          });
+          messages.push(buildStreamRuleReminder(streamRuleHit.rules));
+          yield {
+            type: "stream_rule_triggered",
+            rules: ruleNames,
+            source: streamRuleHit.source,
+            ...streamRuleHit.toolName !== void 0 ? { toolName: streamRuleHit.toolName } : {},
+            attempt,
+            maxAttempts: streamRuleMonitor.maxRetries,
+            usage: abortedUsage
+          };
+          yield {
+            type: "retry",
+            reason: "stream_rule",
+            attempt,
+            maxAttempts: streamRuleMonitor.maxRetries,
+            delayMs: 0,
+            silent: true
+          };
+          turn--;
+          continue;
+        }
         diag("stream_done", {
           events: streamEventCount,
           totalMs: Date.now() - streamCallStart,
@@ -1760,6 +1948,19 @@ function sanitizeOrphanedServerTools(messages) {
     break;
   }
 }
+function countMessageChars(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const p of m.content) {
+        if ("text" in p && typeof p.text === "string") chars += p.text.length;
+        if ("content" in p && typeof p.content === "string") chars += p.content.length;
+      }
+    }
+  }
+  return chars;
+}
 function repairToolPairingAdjacent(messages) {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
@@ -1939,7 +2140,12 @@ var Agent = class {
 0 && (module.exports = {
   Agent,
   AgentStream,
+  DEFAULT_STREAM_RULE_MAX_RETRIES,
+  DEFAULT_STREAM_RULE_WINDOW_CHARS,
+  JsonEscapeDecoder,
+  StreamRuleMonitor,
   agentLoop,
+  buildStreamRuleReminder,
   cancelledBeforeStartText,
   indeterminateOutcomeText,
   isAbortError,
@@ -1947,6 +2153,7 @@ var Agent = class {
   isContextOverflow,
   isLocalBackendUrl,
   isUsageLimitError,
+  repairToolPairingAdjacent,
   setStreamDiagnostic
 });
 //# sourceMappingURL=index.cjs.map