@opencow-ai/opencow-agent-sdk 0.4.23 → 0.4.24

package/dist/client.js

@@ -224458,10 +224458,23 @@ function deepOmitNullProps(value) {
   }
   return value;
 }
-function safeParseToolInputWithNullCoercion(schema, input) {
+function containsUnrecognizedKeysIssue(value) {
+  if (Array.isArray(value))
+    return value.some(containsUnrecognizedKeysIssue);
+  if (value === null || typeof value !== "object")
+    return false;
+  const issue2 = value;
+  if (issue2.code === "unrecognized_keys")
+    return true;
+  return containsUnrecognizedKeysIssue(issue2.errors);
+}
+function safeParseToolInputWithNullCoercion(schema, input, unknownKeys = "strip") {
   const first = schema.safeParse(input);
   if (first.success)
     return first;
+  if (unknownKeys === "reject" && containsUnrecognizedKeysIssue(first.error.issues)) {
+    return first;
+  }
   if (input === null || typeof input !== "object") {
     return first;
   }
@@ -233047,6 +233060,12 @@ function mergeAgentsByType(base2, override) {
     byType.set(agent.agentType, agent);
   return [...byType.values()];
 }
+function withDefaultAgentForInvocation(activeAgents, requestedType, defaultAgent) {
+  if (requestedType !== undefined || activeAgents.some((agent) => agent.agentType === defaultAgent.agentType)) {
+    return activeAgents;
+  }
+  return [...activeAgents, defaultAgent];
+}
 
 // src/capabilities/tools/AgentTool/builtInAgents.ts
 var exports_builtInAgents = {};
@@ -233985,11 +234004,62 @@ var init_generators = __esm(() => {
   NO_VALUE = Symbol("NO_VALUE");
 });
 
+// src/controller/dispatch/permissionPreDecision.ts
+function startPermissionPreDecisions(blocks, assistantMessages, canUseTool, toolUseContext) {
+  const existing = toolUseContext.permissionPreDecisions;
+  if (existing && existing.size > 0) {
+    return;
+  }
+  const preDecisions = new Map;
+  toolUseContext.permissionPreDecisions = preDecisions;
+  for (const block2 of blocks) {
+    const tool = findToolRuntimeByName(toolUseContext.options.tools, block2.name);
+    if (!tool) {
+      continue;
+    }
+    const parsedInput = safeParseToolInputWithNullCoercion(tool.inputSchema, block2.input, tool.unknownKeys);
+    if (!parsedInput.success) {
+      continue;
+    }
+    const assistantMessage = assistantMessages.find((message) => message.message.content.some((content) => content.type === "tool_use" && content.id === block2.id));
+    if (!assistantMessage) {
+      continue;
+    }
+    let input = parsedInput.data;
+    if (tool.backfillObservableInput && typeof input === "object" && input !== null) {
+      input = { ...input };
+      tool.backfillObservableInput(input);
+    }
+    const promise3 = canUseTool(tool, input, toolUseContext, assistantMessage, block2.id);
+    promise3.catch(() => {});
+    preDecisions.set(block2.id, { input, promise: promise3 });
+  }
+}
+function consumePermissionPreDecision(toolUseContext, toolUseID, input, fallback) {
+  const cache2 = toolUseContext.permissionPreDecisions;
+  const entry = cache2?.get(toolUseID);
+  if (!cache2 || !entry) {
+    return fallback();
+  }
+  cache2.delete(toolUseID);
+  if (jsonStringify(entry.input) !== jsonStringify(input)) {
+    return fallback();
+  }
+  return entry.promise;
+}
+var init_permissionPreDecision = __esm(() => {
+  init_toolRuntime();
+  init_slowOperations();
+});
+
 // src/controller/dispatch/toolOrchestration.ts
 function getMaxToolUseConcurrency() {
   return parseInt(resolveEnvVar("MAX_TOOL_USE_CONCURRENCY") || "", 10) || 10;
 }
 async function* runTools(toolUseMessages, assistantMessages, canUseTool, toolUseContext) {
+  if (toolUseContext.options.preDecidePermissions) {
+    startPermissionPreDecisions(toolUseMessages, assistantMessages, canUseTool, toolUseContext);
+  }
   let currentContext = toolUseContext;
   for (const { isConcurrencySafe, blocks } of partitionToolCalls(toolUseMessages, currentContext)) {
     if (isConcurrencySafe) {
@@ -234083,6 +234153,7 @@ var init_toolOrchestration = __esm(() => {
   init_toolRuntime();
   init_generators();
   init_toolExecution();
+  init_permissionPreDecision();
   init_state2();
 });
 
@@ -236316,6 +236387,31 @@ async function* runAgent({
       level: "warn"
     });
   });
+  let partialBaseMessage = null;
+  const partialTextByIndex = new Map;
+  const PARTIAL_PROGRESS_INTERVAL_MS = 50;
+  let lastPartialAssistantAt = 0;
+  let lastPartialProgressHookAt = 0;
+  let foregroundSkipped = 0;
+  let backgroundSkipped = 0;
+  const logPartialProgress = (reason, chars, foregroundEmitted, backgroundEmitted) => {
+    logForDebugging(`[StreamThrottle:SubAgent] ${JSON.stringify({
+      reason,
+      agentId,
+      agentType: agentDefinition.agentType,
+      messageId: partialBaseMessage?.id ?? null,
+      intervalMs: PARTIAL_PROGRESS_INTERVAL_MS,
+      chars,
+      foregroundEmitted,
+      foregroundSkipped,
+      backgroundEmitted,
+      backgroundSkipped
+    })}`);
+    if (foregroundEmitted)
+      foregroundSkipped = 0;
+    if (backgroundEmitted)
+      backgroundSkipped = 0;
+  };
   try {
     const additionalContexts = [];
     for await (const hookResult of executeSubagentStartHooks(agentId, agentDefinition.agentType, agentAbortController.signal, undefined, toolUseContext.toolUseId, isAsync2)) {
@@ -236423,10 +236519,6 @@ async function* runAgent({
       ...description && { description }
     }).catch((_err) => logForDebugging(`Failed to write agent metadata: ${_err}`));
     let lastRecordedUuid = initialMessages.at(-1)?.uuid ?? null;
-    let partialBaseMessage = null;
-    const partialTextByIndex = new Map;
-    const PARTIAL_PROGRESS_HOOK_INTERVAL_MS = 100;
-    let lastPartialProgressHookAt = 0;
     const agentExtraBody = agentDefinition.extraBody;
     const agentQuery = query({
       messages: initialMessages,
@@ -236451,6 +236543,11 @@ async function* runAgent({
       if (message.type === "stream_event") {
         const ev = message.event;
         if (ev.type === "message_start") {
+          if (foregroundSkipped > 0 || backgroundSkipped > 0) {
+            logPartialProgress("message-start", 0, false, false);
+            foregroundSkipped = 0;
+            backgroundSkipped = 0;
+          }
           if (message.ttftMs != null) {
             toolUseContext.pushApiMetricsEntry?.(message.ttftMs);
           }
@@ -236462,22 +236559,36 @@ async function* runAgent({
           const idx = ev.index ?? 0;
           const acc = (partialTextByIndex.get(idx) ?? "") + ev.delta.text;
           partialTextByIndex.set(idx, acc);
-          onPartialAssistant?.({
-            type: "assistant",
-            message: {
-              ...partialBaseMessage,
-              content: [{ type: "text", text: acc, citations: null }]
-            },
-            uuid: randomUUID6(),
-            timestamp: new Date().toISOString()
-          });
+          const now = Date.now();
+          let foregroundEmitted = false;
+          let backgroundEmitted = false;
+          if (onPartialAssistant && now - lastPartialAssistantAt >= PARTIAL_PROGRESS_INTERVAL_MS) {
+            lastPartialAssistantAt = now;
+            foregroundEmitted = true;
+            onPartialAssistant({
+              type: "assistant",
+              message: {
+                ...partialBaseMessage,
+                content: [{ type: "text", text: acc, citations: null }]
+              },
+              uuid: randomUUID6(),
+              timestamp: new Date().toISOString()
+            });
+          } else if (onPartialAssistant) {
+            foregroundSkipped += 1;
+          }
           if (isAsync2) {
-            const now = Date.now();
-            if (now - lastPartialProgressHookAt >= PARTIAL_PROGRESS_HOOK_INTERVAL_MS) {
+            if (now - lastPartialProgressHookAt >= PARTIAL_PROGRESS_INTERVAL_MS) {
               lastPartialProgressHookAt = now;
+              backgroundEmitted = true;
               executeSubagentProgressHooks(agentId, agentDefinition.agentType, partialBaseMessage.id, toolUseContext.toolUseId, [{ type: "text", text: acc }]).catch(() => {});
+            } else {
+              backgroundSkipped += 1;
             }
           }
+          if (foregroundEmitted || backgroundEmitted) {
+            logPartialProgress("emit", acc.length, foregroundEmitted, backgroundEmitted);
+          }
         }
         continue;
       }
@@ -236526,6 +236637,9 @@ async function* runAgent({
     agentRunError = err2;
     throw err2;
   } finally {
+    if (foregroundSkipped > 0 || backgroundSkipped > 0) {
+      logPartialProgress("finalize", 0, false, false);
+    }
     await finalizeLifecycle([
       async () => {
         const naturalStopAlreadyFired = isAsync2 && hasSubagentStopFired(agentId);
@@ -251625,7 +251739,7 @@ var init_AgentTool = __esm(() => {
         }
         selectedAgent = FORK_AGENT;
       } else {
-        const allAgents = toolUseContext.options.agentDefinitions.activeAgents;
+        const allAgents = withDefaultAgentForInvocation(toolUseContext.options.agentDefinitions.activeAgents, subagent_type, GENERAL_PURPOSE_AGENT);
         const {
           allowedAgentTypes
         } = toolUseContext.options.agentDefinitions;
@@ -284597,7 +284711,7 @@ async function resolveHookPermissionDecision(hookPermissionResult, tool, input,
     if (requiresInteraction && !interactionSatisfied || requireCanUseTool) {
       logForDebugging(`Hook approved tool use for ${tool.name}, but canUseTool is required`);
       return {
-        decision: await canUseTool(tool, hookInput, toolUseContext, assistantMessage, toolUseID),
+        decision: await consumePermissionPreDecision(toolUseContext, toolUseID, hookInput, () => canUseTool(tool, hookInput, toolUseContext, assistantMessage, toolUseID)),
         input: hookInput
       };
     }
@@ -284612,7 +284726,7 @@ async function resolveHookPermissionDecision(hookPermissionResult, tool, input,
     }
     logForDebugging(`Hook approved tool use for ${tool.name}, but ask rule requires prompt`);
     return {
-      decision: await canUseTool(tool, hookInput, toolUseContext, assistantMessage, toolUseID),
+      decision: await consumePermissionPreDecision(toolUseContext, toolUseID, hookInput, () => canUseTool(tool, hookInput, toolUseContext, assistantMessage, toolUseID)),
       input: hookInput
     };
   }
@@ -284622,8 +284736,9 @@ async function resolveHookPermissionDecision(hookPermissionResult, tool, input,
   }
   const forceDecision = hookPermissionResult?.behavior === "ask" ? hookPermissionResult : undefined;
   const askInput = hookPermissionResult?.behavior === "ask" && hookPermissionResult.updatedInput ? hookPermissionResult.updatedInput : input;
+  const decision = forceDecision ? await canUseTool(tool, askInput, toolUseContext, assistantMessage, toolUseID, forceDecision) : await consumePermissionPreDecision(toolUseContext, toolUseID, askInput, () => canUseTool(tool, askInput, toolUseContext, assistantMessage, toolUseID));
   return {
-    decision: await canUseTool(tool, askInput, toolUseContext, assistantMessage, toolUseID, forceDecision),
+    decision,
     input: askInput
   };
 }
@@ -284784,6 +284899,7 @@ var init_toolHooks = __esm(() => {
   init_permissions2();
   init_toolErrors();
   init_utils5();
+  init_permissionPreDecision();
 });
 
 // src/controller/dispatch/toolExecution.ts
@@ -285026,9 +285142,8 @@ function streamedCheckPermissionsAndCallTool(tool, toolUseID, input, toolUseCont
   return stream4;
 }
 async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContext, canUseTool, assistantMessage, messageId, requestId, mcpServerType, mcpServerBaseUrl, onToolProgress) {
-  const parsedInput = safeParseToolInputWithNullCoercion(tool.inputSchema, input);
-  if (!parsedInput.success) {
-    let errorContent = formatZodValidationError(tool.name, parsedInput.error);
+  const inputValidationFailure = (error41) => {
+    let errorContent = formatZodValidationError(tool.name, error41);
     const schemaHint = buildSchemaNotSentHint(tool, toolUseContext.messages, toolUseContext.options.tools);
     if (schemaHint) {
       logEvent("tengu_deferred_tool_schema_not_sent", {
@@ -285068,11 +285183,15 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContex
               tool_use_id: toolUseID
             }
           ],
-          toolUseResult: `InputValidationError: ${parsedInput.error.message}`,
+          toolUseResult: `InputValidationError: ${error41.message}`,
           sourceToolAssistantUUID: assistantMessage.uuid
         })
       }
     ];
+  };
+  const parsedInput = safeParseToolInputWithNullCoercion(tool.inputSchema, input, tool.unknownKeys);
+  if (!parsedInput.success) {
+    return inputValidationFailure(parsedInput.error);
   }
   const isValidCall = await tool.validateInput?.(parsedInput.data, toolUseContext);
   if (isValidCall?.result === false) {
@@ -285308,6 +285427,16 @@ async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContex
   if (permissionDecision.updatedInput !== undefined) {
     processedInput = permissionDecision.updatedInput;
   }
+  if (tool.unknownKeys === "reject") {
+    const finalInput = safeParseToolInputWithNullCoercion(tool.inputSchema, processedInput, tool.unknownKeys);
+    if (!finalInput.success) {
+      endToolBlockedOnUserSpan("reject", "input-validation");
+      endToolSpan();
+      resultingMessages.push(...inputValidationFailure(finalInput.error));
+      return resultingMessages;
+    }
+    processedInput = finalInput.data;
+  }
   const telemetryToolInput = extractToolInputForTelemetry(processedInput);
   let toolParameters = {};
   if (isToolDetailsLoggingEnabled()) {
@@ -287656,7 +287785,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-08-28T10:03:59.640Z").getTime();
+  const buildTime = new Date("2026-09-03T09:12:13.936Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -288167,6 +288296,7 @@ function createSubagentContext(parentContext, overrides) {
     dynamicSkillDirTriggers: new Set,
     discoveredSkillNames: new Set,
     toolDecisions: undefined,
+    permissionPreDecisions: undefined,
     contentReplacementState: overrides?.contentReplacementState ?? (parentContext.contentReplacementState ? cloneContentReplacementState(parentContext.contentReplacementState) : undefined),
     abortController,
     getAppState,
@@ -332397,6 +332527,7 @@ class QueryEngine {
       includePartialMessages = false,
       agents = [],
       setSDKStatus,
+      preDecidePermissions,
       onToolInvoke,
       uploadMedia,
       orphanedPermission
@@ -332474,7 +332605,8 @@ class QueryEngine {
         maxOutputTokensLimit,
         contextWindow,
         modelProviders: this.config.modelProviders,
-        subagentDisallowedTools: this.config.subagentDisallowedTools
+        subagentDisallowedTools: this.config.subagentDisallowedTools,
+        preDecidePermissions
       },
       getAppState,
       setAppState,
@@ -332572,7 +332704,8 @@ class QueryEngine {
         maxOutputTokensLimit,
         contextWindow,
         modelProviders: this.config.modelProviders,
-        subagentDisallowedTools: this.config.subagentDisallowedTools
+        subagentDisallowedTools: this.config.subagentDisallowedTools,
+        preDecidePermissions
       },
       getAppState,
       setAppState,
@@ -333089,6 +333222,7 @@ async function* ask({
   handleElicitation,
   agents = [],
   setSDKStatus,
+  preDecidePermissions,
   onToolInvoke,
   uploadMedia,
   orphanedPermission
@@ -333123,6 +333257,7 @@ async function* ask({
     replayUserMessages,
     includePartialMessages,
     setSDKStatus,
+    preDecidePermissions,
     onToolInvoke,
     uploadMedia,
     abortController,
@@ -334528,11 +334663,12 @@ init_callToolResultAdapter();
 init_toolRuntime();
 import { randomUUID as randomUUID20 } from "node:crypto";
 function toInternalTool(sdkTool) {
-  const zodObjectInputSchema = exports_external2.object(sdkTool.inputSchema);
+  const zodObjectInputSchema = sdkTool.unknownKeys === "reject" ? exports_external2.strictObject(sdkTool.inputSchema) : exports_external2.object(sdkTool.inputSchema);
   const internalTool = buildToolRuntime({
     name: sdkTool.name,
     maxResultSizeChars: 1e5,
     inputSchema: zodObjectInputSchema,
+    unknownKeys: sdkTool.unknownKeys,
     isMcp: false,
     shouldDefer: sdkTool.shouldDefer,
     isReadOnly: () => sdkTool.isReadOnly ?? false,
@@ -340705,6 +340841,7 @@ function runSdkQueryRuntime(params) {
           taskBudget: options2.taskBudget,
           subagentDisallowedTools: options2.subagentDisallowedTools,
           canUseTool,
+          preDecidePermissions: options2.preDecidePermissions === true,
           mutableMessages,
           getReadFileCache: () => readFileCache,
           setReadFileCache: (cache3) => {
@@ -342043,4 +342180,4 @@ export {
   watchScheduledTasks
 };
 
-//# debugId=86D753D16BFADB1B64756E2164756E21
+//# debugId=4C54109188AEF71964756E2164756E21

package/dist/controller/dispatch/permissionPreDecision.d.ts

@@ -0,0 +1,22 @@
+import type { CanonicalToolUseBlock as ToolUseBlock } from '../../session/canonical/index.js';
+import { type CanUseToolFn, type ToolRuntimeContext } from '../../types/toolRuntime.js';
+import type { AssistantMessage } from '../../types/message.js';
+import type { PermissionResult } from '../../types/permissions.js';
+/**
+ * 权限决策前置：runTools() 入口对同批全部 tool_use 并发预调 canUseTool，把
+ * 决策 promise 缓存到 toolUseContext.permissionPreDecisions；工具仍按原顺序
+ * 独占执行，执行时经 consumePermissionPreDecision 消费缓存，避免串行批里
+ * host 审批逐个阻塞弹出。
+ *
+ * 与执行期（checkPermissionsAndCallTool）对齐的规范化：找不到 tool runtime、
+ * zod 校验失败的块跳过（执行期走各自的内联错误路径，本就不该有预决策）；
+ * backfillObservableInput 在浅克隆上调用，与执行期 backfill 后的 observable
+ * input 保持一致，保证消费时深比较有命中机会。
+ */
+export declare function startPermissionPreDecisions(blocks: ToolUseBlock[], assistantMessages: AssistantMessage[], canUseTool: CanUseToolFn, toolUseContext: ToolRuntimeContext): void;
+/**
+ * 一次性消费预决策：无缓存 / input 与执行期不一致（hook 改写等）时回退
+ * fallback 内联询问；命中则返回缓存 promise。无论命中与否，条目取出即删——
+ * 后续同名 tool_use（如 forceDecision 场景）必须重新询问。
+ */
+export declare function consumePermissionPreDecision(toolUseContext: ToolRuntimeContext, toolUseID: string, input: Record<string, unknown>, fallback: () => Promise<PermissionResult>): Promise<PermissionResult>;

package/dist/entrypoints/sdk/runtimeTypes.d.ts

@@ -287,6 +287,17 @@ export type Options = {
     replayUserMessages?: boolean;
     permissionMode?: string;
     canUseTool?: SdkCanUseTool;
+    /**
+     * 权限决策前置。开启后，同一批 queued tool_use 的 canUseTool 会在工具调度
+     * 入口并发预调并缓存结果；工具仍按原顺序独占执行（串行语义、context
+     * modifier 顺序、级联取消均不变），执行时消费缓存决策，不再逐个阻塞等待
+     * host 审批。PreToolUse hook 改写 input 或给出 ask 消息时缓存自动 miss，
+     * 回退执行期内联询问。
+     *
+     * mechanism / policy 分层：SDK 只提供预决策机制，默认 false，是否开启由
+     * host 决定（host 需接受 canUseTool 被并发调用）。
+     */
+    preDecidePermissions?: boolean;
     mcpServers?: Record<string, McpServerConfig>;
     /**
      * Selects the SDK-owned built-in tool set for this query.

package/dist/lib/toolInputNullCoercion.d.ts

@@ -20,4 +20,4 @@ import type { z } from 'zod/v4';
  * 习惯性回传 `null`，只剥顶层会漏掉它们、导致整个阻塞工具因校验失败被跳过（handler
  * 不执行、不阻塞，对话直接溜到下一轮）。
  */
-export declare function safeParseToolInputWithNullCoercion<T extends z.ZodType>(schema: T, input: unknown): ReturnType<T['safeParse']>;
+export declare function safeParseToolInputWithNullCoercion<T extends z.ZodType>(schema: T, input: unknown, unknownKeys?: 'strip' | 'reject'): ReturnType<T['safeParse']>;