blun-king-cli 9.1.343 → 9.1.345

package/bin/cognitive-turn-lifecycle.cjs

@@ -198,6 +198,50 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     ]);
   }
 
+  function recordToolBatch(input) {
+    if (!exactKeys(input, new Set(['turnId', 'entries']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    if (turnId === null || !Array.isArray(input.entries) || input.entries.length < 1 || input.entries.length > 10) {
+      fail('COGNITIVE_LIFECYCLE_INVALID');
+    }
+    const observations = [];
+    const stageParts = [];
+    for (const entry of input.entries) {
+      const { toolCallId, toolName, callKey } = toolFields(
+        { turnId, ...entry },
+        new Set(['turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs']),
+      );
+      const decision = String(entry.decision ?? '');
+      const outcome = String(entry.outcome ?? '');
+      const durationMs = Number(entry.durationMs);
+      if (!TOOL_POLICY_DECISIONS.has(decision) || !TOOL_OUTCOMES.has(outcome)
+          || !Number.isSafeInteger(durationMs) || durationMs < 0) fail('COGNITIVE_LIFECYCLE_INVALID');
+      stageParts.push(`${toolCallId}:${decision}:${outcome}:${durationMs}`);
+      observations.push({
+        domain: 'world',
+        key: `turn:${turnId}:${callKey}:tool-policy`,
+        value: `${decision}:runtime_tool_policy:${toolName}`,
+        confidence: 1,
+        scope: 'runtime',
+      }, {
+        domain: 'expected_evidence',
+        key: `turn:${turnId}:${callKey}:tool-result`,
+        value: `${outcome}:${durationMs}ms:${toolName}`,
+        confidence: 1,
+        scope: 'runtime',
+      }, {
+        domain: 'next_trigger',
+        key: `turn:${turnId}:${callKey}:tool-next`,
+        value: outcome === 'success' ? 'continue-after-tool' : 'inspect-tool-failure',
+        confidence: 1,
+        scope: 'runtime',
+      });
+    }
+    const batchKey = digestId('toolbatch', stageParts);
+    const result = commitStage(`turn-${turnId}-${batchKey}`, observations);
+    return { ...result, events: 1, entries: input.entries.length };
+  }
+
   function projectForTurn(input) {
     if (!exactKeys(input, new Set(['turnId', 'focusScopes']))) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
@@ -226,6 +270,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     recordRightsCheck,
     recordToolPolicy,
     recordToolResult,
+    recordToolBatch,
     recordFocusSnapshot,
     authorizeAttention,
     projectForTurn,

package/bin/streaming-flush-performance-policy.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const SHORT_STREAM_MAX_CHARS = 8_192;
+const MEDIUM_STREAM_MAX_CHARS = 32_768;
+const LONG_STREAM_MAX_CHARS = 131_072;
+
+function safeChars(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+
+function resolveStreamingFlushInterval(input = {}) {
+  const chars = Math.max(safeChars(input.assistantChars), safeChars(input.thinkingChars));
+  if (chars <= SHORT_STREAM_MAX_CHARS) return 50;
+  if (chars <= MEDIUM_STREAM_MAX_CHARS) return 100;
+  if (chars <= LONG_STREAM_MAX_CHARS) return 250;
+  return 500;
+}
+
+module.exports = {
+  LONG_STREAM_MAX_CHARS,
+  MEDIUM_STREAM_MAX_CHARS,
+  SHORT_STREAM_MAX_CHARS,
+  resolveStreamingFlushInterval,
+};

package/blun.mjs

@@ -261553,6 +261553,8 @@ var init_turn = __esmMin((() => {
 		currentStep = 0;
 		cognitiveLifecycle;
 		cognitiveLifecycleUnavailable = false;
+		cognitiveToolPolicyByCall = /* @__PURE__ */ new Map();
+		cognitiveToolBatchesByTurn = /* @__PURE__ */ new Map();
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261587,6 +261589,40 @@ var init_turn = __esmMin((() => {
 				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: method, error_type: error?.code ?? error?.name ?? "Error" });
 			}
 		}
+		bufferCognitiveToolPolicy(input) {
+			this.cognitiveToolPolicyByCall.set(input.toolCallId, input);
+		}
+		bufferCognitiveToolResult(input) {
+			const policy = this.cognitiveToolPolicyByCall.get(input.toolCallId);
+			if (policy === void 0 || policy.turnId !== input.turnId) {
+				this.recordCognitiveStage("recordToolResult", input);
+				return;
+			}
+			this.cognitiveToolPolicyByCall.delete(input.toolCallId);
+			const entries = this.cognitiveToolBatchesByTurn.get(input.turnId) ?? [];
+			entries.push({
+				toolCallId: input.toolCallId,
+				toolName: input.toolName,
+				decision: policy.decision,
+				outcome: input.outcome,
+				durationMs: input.durationMs
+			});
+			this.cognitiveToolBatchesByTurn.set(input.turnId, entries);
+		}
+		flushCognitiveToolEvidence(turnId, includePending) {
+			const entries = this.cognitiveToolBatchesByTurn.get(turnId) ?? [];
+			this.cognitiveToolBatchesByTurn.delete(turnId);
+			for (let offset = 0; offset < entries.length; offset += 10) this.recordCognitiveStage("recordToolBatch", {
+				turnId,
+				entries: entries.slice(offset, offset + 10)
+			});
+			if (!includePending) return;
+			for (const [toolCallId, policy] of this.cognitiveToolPolicyByCall) {
+				if (policy.turnId !== turnId) continue;
+				this.cognitiveToolPolicyByCall.delete(toolCallId);
+				this.recordCognitiveStage("recordToolPolicy", policy);
+			}
+		}
 		projectCognitiveState(turnId) {
 			try {
 				return this.getCognitiveLifecycle()?.projectForTurn({ turnId }) ?? null;
@@ -261948,6 +261984,7 @@ var init_turn = __esmMin((() => {
 				durationMs: Date.now() - startedAt
 			};
 			this.agent.usage.endTurn();
+			this.flushCognitiveToolEvidence(turnId, true);
 			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			return ended;
@@ -262062,6 +262099,7 @@ var init_turn = __esmMin((() => {
 				mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
 				...this.requestProviderProps()
 			});
+			this.flushCognitiveToolEvidence(turnId, true);
 			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			this.agent.endResponderTurn();
@@ -262270,6 +262308,7 @@ var init_turn = __esmMin((() => {
 							},
 							afterStep: async ({ usage }) => {
 								previousStepToolOutcome = currentStepHadTool ? currentStepHadFailure ? "failure" : "success" : "none";
+								this.flushCognitiveToolEvidence(turnId, false);
 								this.agent.usage.record(this.agent.activeResponderModel ?? model, usage, "turn");
 								if (stopForGoalBudget) this.setActiveSteerAcceptance(turnId, false);
 								await this.agent.toolResultBatchOffload.detect();
@@ -262322,7 +262361,7 @@ var init_turn = __esmMin((() => {
 							authorizeToolExecution: async (ctx) => {
 								try {
 									const resolution = await this.agent.permission.beforeToolCall(ctx);
-									this.recordCognitiveStage("recordToolPolicy", {
+									this.bufferCognitiveToolPolicy({
 										turnId,
 										toolCallId: ctx.toolCall.id,
 										toolName: ctx.toolCall.name,
@@ -262330,7 +262369,7 @@ var init_turn = __esmMin((() => {
 									});
 									return resolution;
 								} catch (error) {
-									this.recordCognitiveStage("recordToolPolicy", {
+									this.bufferCognitiveToolPolicy({
 										turnId,
 										toolCallId: ctx.toolCall.id,
 										toolName: ctx.toolCall.name,
@@ -262480,7 +262519,7 @@ var init_turn = __esmMin((() => {
 				};
 				const errorType = outcome === "error" ? telemetryToolErrorType(event.result) : void 0;
 				if (errorType !== void 0) properties["error_type"] = errorType;
-				this.recordCognitiveStage("recordToolResult", {
+				this.bufferCognitiveToolResult({
 					turnId,
 					toolCallId: event.toolCallId,
 					toolName: started.name,
@@ -511375,7 +511414,11 @@ var StreamingUIController = class {
 	scheduleFlush() {
 		if (!this.hasPending()) return;
 		if (this.flushTimer !== void 0) return;
-		const delay = this.lastFlushAt === void 0 ? 0 : Math.max(0, 50 - (Date.now() - this.lastFlushAt));
+		const flushIntervalMs = resolveStreamingFlushInterval({
+			assistantChars: this._assistantDraft.length,
+			thinkingChars: this._thinkingDraft.length
+		});
+		const delay = this.lastFlushAt === void 0 ? 0 : Math.max(0, flushIntervalMs - (Date.now() - this.lastFlushAt));
 		this.flushTimer = setTimeout(() => {
 			this.flushTimer = void 0;
 			this.flush();
@@ -515874,6 +515917,7 @@ const {
 	readRunningUpdateMode,
 	writeRunningUpdateMode
 } = __require("./bin/running-update-preference.cjs");
+const { resolveStreamingFlushInterval } = __require("./bin/streaming-flush-performance-policy.cjs");
 const RUNNING_UPDATE_RESUME_SESSION_ENV = "BLUN_RUNNING_UPDATE_RESUME_SESSION_ID";
 function shouldContinueActiveGoalAfterRunningUpdate(expectedSessionId, currentSessionId, goalStatus) {
 	return typeof expectedSessionId === "string" && expectedSessionId.length > 0 && currentSessionId === expectedSessionId && goalStatus === "active";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.343",
+  "version": "9.1.345",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {