pybao-cli 1.5.7 → 1.5.9

package/dist/{llm-T7C6QJWB.js → llm-6VJMMPDO.js}

@@ -2,39 +2,37 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   getToolDescription
-} from "./chunk-O6DTZU7F.js";
+} from "./chunk-OC5CZWBQ.js";
 import {
-  emitTelemetryEvent,
   formatSystemPromptWithContext,
   generatePybContext,
   getCLISyspromptPrefix,
-  getModelCapabilities,
   getReasoningEffort,
   models_default,
-  refreshPybContext,
-  resolveModelResponsePolicy
-} from "./chunk-SWNNPHFY.js";
-import "./chunk-JEAXJP2E.js";
-import "./chunk-5JKCAVMI.js";
-import "./chunk-CJ2YYIJN.js";
+  refreshPybContext
+} from "./chunk-PH6DPTO3.js";
+import "./chunk-Q5EZLUFC.js";
+import "./chunk-JLC2I3EY.js";
+import "./chunk-L3R7MPZU.js";
+import "./chunk-BZGQQ4WZ.js";
+import "./chunk-PPFVOBEG.js";
+import "./chunk-T7P3SSAQ.js";
 import "./chunk-F4AXICO7.js";
-import "./chunk-4R7NUADF.js";
-import "./chunk-ZD6NMP33.js";
 import "./chunk-5P7HBXTD.js";
-import "./chunk-T7UTA73F.js";
-import "./chunk-3JH34RBY.js";
+import "./chunk-TLZS274Y.js";
+import "./chunk-6PXEXL7C.js";
 import {
   getCompletionWithProfile,
   getGPT5CompletionWithProfile
-} from "./chunk-4BFEUSKN.js";
+} from "./chunk-CATWZQ3R.js";
 import "./chunk-XKYHFZEC.js";
-import "./chunk-KLD4WAB6.js";
-import "./chunk-OY6SB5B3.js";
-import "./chunk-VBV5RHIK.js";
-import "./chunk-7FFBXWS3.js";
+import "./chunk-KNLP4UO6.js";
+import "./chunk-276RV4DQ.js";
+import "./chunk-R4ZEH3KJ.js";
+import "./chunk-35X2VS4L.js";
 import "./chunk-UNNVICVU.js";
-import "./chunk-IOP3VA4X.js";
-import "./chunk-PI5RBPFA.js";
+import "./chunk-YSL5H7NJ.js";
+import "./chunk-DA6NJEFI.js";
 import "./chunk-A3BVXXA3.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
@@ -44,8 +42,9 @@ import {
   NO_CONTENT_MESSAGE,
   PROMPT_TOO_LONG_ERROR_MESSAGE,
   createAssistantAPIErrorMessage,
+  emitTelemetryEvent,
   normalizeContentFromAPI
-} from "./chunk-YNGGZILT.js";
+} from "./chunk-JRMAK4PK.js";
 import {
   processResponsesStream
 } from "./chunk-OMELVAJD.js";
@@ -56,27 +55,27 @@ import "./chunk-B6IMQJZM.js";
 import {
   addToTotalCost
 } from "./chunk-OUXHGDLH.js";
-import "./chunk-SDKYJZWD.js";
+import "./chunk-57GJQMFS.js";
 import "./chunk-QWIBSCDN.js";
-import "./chunk-EGJRWKZ6.js";
-import "./chunk-F7HYDAWW.js";
-import "./chunk-5F6IQJHF.js";
+import "./chunk-CPLMSZ63.js";
+import "./chunk-JE43CQYI.js";
+import "./chunk-HIJYNCCN.js";
 import "./chunk-UZ34JEUK.js";
-import "./chunk-VZDDKAL2.js";
+import "./chunk-4C2CGHBI.js";
 import "./chunk-BJSWTHRM.js";
 import {
   USE_BEDROCK,
   USE_VERTEX,
   getModelManager,
   getVertexRegionForModel
-} from "./chunk-LYMH46VN.js";
-import "./chunk-IFC2PLAM.js";
-import "./chunk-EN7L7JWN.js";
-import "./chunk-Y2RSIF7P.js";
+} from "./chunk-QMN64ICT.js";
+import "./chunk-E35YJNX2.js";
+import "./chunk-LIOZM4KE.js";
+import "./chunk-4KPVE4K7.js";
 import {
   getAnthropicApiKey,
   getGlobalConfig
-} from "./chunk-PMYMUSB4.js";
+} from "./chunk-LEYWQQ7V.js";
 import "./chunk-RQVLBMP7.js";
 import {
   debug,
@@ -85,16 +84,16 @@ import {
   logLLMInteraction,
   logSystemPromptConstruction,
   markPhase
-} from "./chunk-IKMMFSNJ.js";
+} from "./chunk-AMQ6XZOU.js";
 import {
   PRODUCT_COMMAND,
   env,
   getCwd,
   logError
-} from "./chunk-TIMEEE5U.js";
+} from "./chunk-G7DKRXDS.js";
 import {
   MACRO
-} from "./chunk-W4PXRGP3.js";
+} from "./chunk-AWRDD6BG.js";
 import "./chunk-I3J4JYES.js";
 
 // src/services/ai/llm.ts
@@ -1172,6 +1171,151 @@ var ChatCompletionsAdapter = class extends OpenAIAdapter {
   }
 };
 
+// src/constants/modelCapabilities.ts
+var GPT5_CAPABILITIES = {
+  apiArchitecture: {
+    primary: "responses_api",
+    fallback: "chat_completions"
+  },
+  parameters: {
+    maxTokensField: "max_output_tokens",
+    supportsReasoningEffort: true,
+    supportsVerbosity: true,
+    temperatureMode: "fixed_one"
+  },
+  toolCalling: {
+    mode: "custom_tools",
+    supportsFreeform: true,
+    supportsAllowedTools: true,
+    supportsParallelCalls: true
+  },
+  stateManagement: {
+    supportsResponseId: true,
+    supportsConversationChaining: true,
+    supportsPreviousResponseId: true
+  },
+  streaming: {
+    supported: true,
+    includesUsage: true
+  }
+};
+var CHAT_COMPLETIONS_CAPABILITIES = {
+  apiArchitecture: {
+    primary: "chat_completions"
+  },
+  parameters: {
+    maxTokensField: "max_tokens",
+    supportsReasoningEffort: false,
+    supportsVerbosity: false,
+    temperatureMode: "flexible"
+  },
+  toolCalling: {
+    mode: "function_calling",
+    supportsFreeform: false,
+    supportsAllowedTools: false,
+    supportsParallelCalls: true
+  },
+  stateManagement: {
+    supportsResponseId: false,
+    supportsConversationChaining: false,
+    supportsPreviousResponseId: false
+  },
+  streaming: {
+    supported: true,
+    includesUsage: true
+  }
+};
+var MODEL_CAPABILITIES_REGISTRY = {
+  "gpt-5": GPT5_CAPABILITIES,
+  "gpt-5-mini": GPT5_CAPABILITIES,
+  "gpt-5-nano": GPT5_CAPABILITIES,
+  "gpt-5-chat-latest": GPT5_CAPABILITIES,
+  "gpt-5-codex": GPT5_CAPABILITIES,
+  "gpt-4o": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4o-mini": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4-turbo": CHAT_COMPLETIONS_CAPABILITIES,
+  "gpt-4": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-5-sonnet-20241022": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-5-haiku-20241022": CHAT_COMPLETIONS_CAPABILITIES,
+  "claude-3-opus-20240229": CHAT_COMPLETIONS_CAPABILITIES,
+  o1: {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  },
+  "o1-mini": {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  },
+  "o1-preview": {
+    ...CHAT_COMPLETIONS_CAPABILITIES,
+    parameters: {
+      ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+      maxTokensField: "max_completion_tokens",
+      temperatureMode: "fixed_one"
+    }
+  }
+};
+function inferModelCapabilities(modelName) {
+  if (!modelName) return null;
+  const lowerName = modelName.toLowerCase();
+  if (lowerName.includes("gpt-5") || lowerName.includes("gpt5")) {
+    return GPT5_CAPABILITIES;
+  }
+  if (lowerName.includes("gpt-6") || lowerName.includes("gpt6")) {
+    return {
+      ...GPT5_CAPABILITIES,
+      streaming: { supported: true, includesUsage: true }
+    };
+  }
+  if (lowerName.includes("glm-5") || lowerName.includes("glm5")) {
+    return {
+      ...CHAT_COMPLETIONS_CAPABILITIES,
+      toolCalling: {
+        ...CHAT_COMPLETIONS_CAPABILITIES.toolCalling,
+        supportsAllowedTools: false
+      }
+    };
+  }
+  if (lowerName.startsWith("o1") || lowerName.includes("o1-")) {
+    return {
+      ...CHAT_COMPLETIONS_CAPABILITIES,
+      parameters: {
+        ...CHAT_COMPLETIONS_CAPABILITIES.parameters,
+        maxTokensField: "max_completion_tokens",
+        temperatureMode: "fixed_one"
+      }
+    };
+  }
+  return null;
+}
+var capabilityCache = /* @__PURE__ */ new Map();
+function getModelCapabilities(modelName) {
+  if (capabilityCache.has(modelName)) {
+    return capabilityCache.get(modelName);
+  }
+  if (MODEL_CAPABILITIES_REGISTRY[modelName]) {
+    const capabilities = MODEL_CAPABILITIES_REGISTRY[modelName];
+    capabilityCache.set(modelName, capabilities);
+    return capabilities;
+  }
+  const inferred = inferModelCapabilities(modelName);
+  if (inferred) {
+    capabilityCache.set(modelName, inferred);
+    return inferred;
+  }
+  const defaultCapabilities = CHAT_COMPLETIONS_CAPABILITIES;
+  capabilityCache.set(modelName, defaultCapabilities);
+  return defaultCapabilities;
+}
+
 // src/services/ai/modelAdapterFactory.ts
 var ModelAdapterFactory = class {
   static createAdapter(modelProfile) {
@@ -1536,6 +1680,142 @@ function convertAnthropicMessagesToOpenAIMessages(messages) {
   return finalMessages;
 }
 
+// src/services/ai/policyDispatch/policyConfigLoader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join, resolve } from "path";
+
+// src/services/ai/policyDispatch/policyConfigSchema.ts
+import { z } from "zod";
+var policyConfigSchema = z.object({
+  version: z.string().min(1),
+  defaults: z.object({
+    reasoningPolicy: z.enum([
+      "preserve_reasoning_blocks",
+      "map_to_provider_options",
+      "flatten_to_text_fallback"
+    ]).optional(),
+    normalizeProviderContent: z.boolean().optional(),
+    trimCrossModelMetadata: z.boolean().optional()
+  }).optional(),
+  overrides: z.array(
+    z.object({
+      model: z.string().min(1).optional(),
+      modelFamily: z.string().min(1).optional(),
+      provider: z.string().min(1).optional(),
+      scenario: z.enum(["query", "auto_compact", "other"]).optional(),
+      reasoningPolicy: z.enum([
+        "preserve_reasoning_blocks",
+        "map_to_provider_options",
+        "flatten_to_text_fallback"
+      ]).optional(),
+      normalizeProviderContent: z.boolean().optional(),
+      trimCrossModelMetadata: z.boolean().optional()
+    })
+  ).optional().default([])
+});
+
+// src/services/ai/policyDispatch/policyConfigLoader.ts
+function getModelFamily(model) {
+  const normalized = String(model || "").toLowerCase();
+  if (normalized.startsWith("gpt-5")) return "gpt-5";
+  if (normalized.startsWith("gpt-4o")) return "gpt-4o";
+  if (!normalized) return "unknown";
+  const segments = normalized.split("-");
+  return segments.length >= 2 ? `${segments[0]}-${segments[1]}` : normalized;
+}
+function getDefaultPolicyConfigPath() {
+  return resolve(join(process.cwd(), "config/auto-compact-policy.config.json"));
+}
+function loadAutoCompactPolicyConfig(options) {
+  const filePath = resolve(options?.filePath ?? getDefaultPolicyConfigPath());
+  if (!existsSync2(filePath)) return null;
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return policyConfigSchema.parse(parsed);
+  } catch {
+    return null;
+  }
+}
+function matches(input, override) {
+  if (override.model && override.model !== input.model) return false;
+  if (override.modelFamily && override.modelFamily !== getModelFamily(input.model))
+    return false;
+  if (override.provider && override.provider !== input.provider) return false;
+  if (override.scenario && override.scenario !== input.source) return false;
+  return true;
+}
+function selectPolicyOverride(input, config) {
+  const matched = [...config.overrides ?? []].reverse().find((item) => matches(input, item));
+  if (matched) {
+    return {
+      reasoningPolicy: matched.reasoningPolicy,
+      normalizeProviderContent: matched.normalizeProviderContent,
+      trimCrossModelMetadata: matched.trimCrossModelMetadata
+    };
+  }
+  if (config.defaults) {
+    return {
+      reasoningPolicy: config.defaults.reasoningPolicy,
+      normalizeProviderContent: config.defaults.normalizeProviderContent,
+      trimCrossModelMetadata: config.defaults.trimCrossModelMetadata
+    };
+  }
+  return null;
+}
+
+// src/services/ai/policyDispatch/index.ts
+function resolveDefaultReasoningPolicy(model) {
+  const capabilities = getModelCapabilities(model);
+  if (capabilities.apiArchitecture.primary === "responses_api") {
+    return "map_to_provider_options";
+  }
+  return "preserve_reasoning_blocks";
+}
+function resolveDefaultNormalizeProviderContent(model) {
+  const capabilities = getModelCapabilities(model);
+  return capabilities.apiArchitecture.primary === "responses_api";
+}
+function resolveDefaultTrimCrossModelMetadata(model) {
+  const capabilities = getModelCapabilities(model);
+  return capabilities.apiArchitecture.primary === "responses_api";
+}
+function resolveCapabilityDefaults(model) {
+  return {
+    reasoningPolicy: resolveDefaultReasoningPolicy(model),
+    normalizeProviderContent: resolveDefaultNormalizeProviderContent(model),
+    trimCrossModelMetadata: resolveDefaultTrimCrossModelMetadata(model)
+  };
+}
+function resolveModelResponsePolicy(input) {
+  const defaults = resolveCapabilityDefaults(input.model);
+  const hasOverride = input.reasoningPolicy !== void 0 || input.normalizeProviderContent !== void 0 || input.trimCrossModelMetadata !== void 0;
+  if (hasOverride) {
+    return {
+      reasoningPolicy: input.reasoningPolicy ?? defaults.reasoningPolicy,
+      normalizeProviderContent: input.normalizeProviderContent ?? defaults.normalizeProviderContent,
+      trimCrossModelMetadata: input.trimCrossModelMetadata ?? defaults.trimCrossModelMetadata,
+      policySource: "context_override"
+    };
+  }
+  const config = loadAutoCompactPolicyConfig();
+  const selection = config ? selectPolicyOverride(input, config) : null;
+  if (selection && (selection.reasoningPolicy !== void 0 || selection.normalizeProviderContent !== void 0 || selection.trimCrossModelMetadata !== void 0)) {
+    return {
+      reasoningPolicy: selection.reasoningPolicy ?? defaults.reasoningPolicy,
+      normalizeProviderContent: selection.normalizeProviderContent ?? defaults.normalizeProviderContent,
+      trimCrossModelMetadata: selection.trimCrossModelMetadata ?? defaults.trimCrossModelMetadata,
+      policySource: "policy_config"
+    };
+  }
+  return {
+    reasoningPolicy: defaults.reasoningPolicy,
+    normalizeProviderContent: defaults.normalizeProviderContent,
+    trimCrossModelMetadata: defaults.trimCrossModelMetadata,
+    policySource: "model_capabilities"
+  };
+}
+
 // src/services/ai/messageTransform/policies.ts
 function resolvePolicies(context) {
   return resolveModelResponsePolicy({
@@ -1657,6 +1937,7 @@ function applyProviderRules(messages, options) {
 
 // src/services/ai/messageTransform/index.ts
 var MESSAGE_TRANSFORM_RULE_VERSION = "b2-enhanced-v1";
+var DEFAULT_PRUNE_PLACEHOLDER = "[pruned historical tool output]";
 function collectBlockStats(messages) {
   const stats = {};
   for (const message of messages) {
@@ -1669,8 +1950,63 @@ function collectBlockStats(messages) {
   }
   return stats;
 }
+function getPruneCheckpointIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const state = messages[index]?.message?.compaction?.prune?.state ?? messages[index]?.message?.metadata?.compaction?.prune?.state;
+    if (state === "compacted") return index;
+  }
+  return -1;
+}
+function isToolLikeBlock(block) {
+  if (!block || typeof block !== "object") return false;
+  const type = String(block.type ?? "");
+  if (type === "tool_result" || type === "tool_use" || type === "tool-use" || type === "tool-call" || type === "tool_output" || type === "tool-output") {
+    return true;
+  }
+  return "toolUseId" in block || "tool_use_id" in block || "toolCallId" in block || "tool_call_id" in block;
+}
+function applyPruneExecution(messages, context) {
+  if (!context.pruneExecutionEnabled) {
+    return { transformed: messages, replacedBlocks: 0, replacedTextMessages: 0 };
+  }
+  const checkpointIndex = getPruneCheckpointIndex(messages);
+  if (checkpointIndex <= 0) {
+    return { transformed: messages, replacedBlocks: 0, replacedTextMessages: 0 };
+  }
+  const placeholder = context.pruneExecutionPlaceholder?.trim() || DEFAULT_PRUNE_PLACEHOLDER;
+  let replacedBlocks = 0;
+  let replacedTextMessages = 0;
+  const transformed = messages.map((message, index) => {
+    if (index >= checkpointIndex) return message;
+    const content = message?.message?.content;
+    if (Array.isArray(content)) {
+      let changed = false;
+      const nextContent = content.map((block) => {
+        if (!isToolLikeBlock(block)) return block;
+        changed = true;
+        replacedBlocks += 1;
+        return {
+          type: "text",
+          text: placeholder
+        };
+      });
+      if (!changed) return message;
+      return {
+        ...message,
+        message: {
+          ...message.message,
+          content: nextContent
+        }
+      };
+    }
+    return message;
+  });
+  return { transformed, replacedBlocks, replacedTextMessages };
+}
 function transformMessagesForModel(messages, context) {
   const resolved = resolvePolicies(context);
+  const pruneExecutionResult = applyPruneExecution(messages, context);
+  const inputMessages = pruneExecutionResult.transformed;
   if (process.env.PYB_MESSAGE_TRANSFORM_ENABLED === "0") {
     const payload2 = {
       source: context.source,
@@ -1684,8 +2020,11 @@ function transformMessagesForModel(messages, context) {
       ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
       ruleHits: createDefaultRuleHits(),
       reason: "disabled",
-      messageCount: messages.length,
-      outputBlockStats: collectBlockStats(messages)
+      messageCount: inputMessages.length,
+      outputBlockStats: collectBlockStats(inputMessages),
+      pruneExecutionEnabled: context.pruneExecutionEnabled === true,
+      pruneExecutionReplacedBlocks: pruneExecutionResult.replacedBlocks,
+      pruneExecutionReplacedTextMessages: pruneExecutionResult.replacedTextMessages
     };
     debug.state("MESSAGE_TRANSFORM_SKIPPED", payload2);
     emitTelemetryEvent({
@@ -1694,7 +2033,7 @@ function transformMessagesForModel(messages, context) {
       data: payload2,
       timestamp: Date.now()
     });
-    return messages;
+    return inputMessages;
   }
   const dryRun = process.env.PYB_MESSAGE_TRANSFORM_DRY_RUN === "1";
   if (dryRun) {
@@ -1709,8 +2048,11 @@ function transformMessagesForModel(messages, context) {
       policySource: resolved.policySource,
       ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
       ruleHits: createDefaultRuleHits(),
-      messageCount: messages.length,
-      outputBlockStats: collectBlockStats(messages)
+      messageCount: inputMessages.length,
+      outputBlockStats: collectBlockStats(inputMessages),
+      pruneExecutionEnabled: context.pruneExecutionEnabled === true,
+      pruneExecutionReplacedBlocks: pruneExecutionResult.replacedBlocks,
+      pruneExecutionReplacedTextMessages: pruneExecutionResult.replacedTextMessages
     };
     debug.state("MESSAGE_TRANSFORM_APPLIED", payload2);
     emitTelemetryEvent({
@@ -1719,9 +2061,9 @@ function transformMessagesForModel(messages, context) {
       data: payload2,
       timestamp: Date.now()
     });
-    return messages;
+    return inputMessages;
   }
-  const { transformed, ruleHits } = applyProviderRules(messages, {
+  const { transformed, ruleHits } = applyProviderRules(inputMessages, {
     model: context.model,
     reasoningPolicy: resolved.reasoningPolicy,
     normalizeProviderContent: resolved.normalizeProviderContent,
@@ -1738,8 +2080,11 @@ function transformMessagesForModel(messages, context) {
     policySource: resolved.policySource,
     ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
     ruleHits,
-    messageCount: messages.length,
-    outputBlockStats: collectBlockStats(transformed)
+    messageCount: inputMessages.length,
+    outputBlockStats: collectBlockStats(transformed),
+    pruneExecutionEnabled: context.pruneExecutionEnabled === true,
+    pruneExecutionReplacedBlocks: pruneExecutionResult.replacedBlocks,
+    pruneExecutionReplacedTextMessages: pruneExecutionResult.replacedTextMessages
   };
   debug.state("MESSAGE_TRANSFORM_APPLIED", payload);
   emitTelemetryEvent({
@@ -1756,7 +2101,9 @@ function buildMessageTransformContext(params) {
   return {
     source: params.source,
     model: params.model,
-    provider: params.provider ?? "openai"
+    provider: params.provider ?? "openai",
+    pruneExecutionEnabled: params.pruneExecutionEnabled,
+    pruneExecutionPlaceholder: params.pruneExecutionPlaceholder
   };
 }
 
@@ -1765,6 +2112,23 @@ function isGPT5Model(modelName) {
   return modelName.startsWith("gpt-5");
 }
 var PROMPT_CACHING_ENABLED = !process.env.DISABLE_PROMPT_CACHING;
+function parseBooleanFlag(value) {
+  if (value === void 0) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return null;
+}
+function resolvePruneExecutionEnabled(_toolUseContext) {
+  const explicit = parseBooleanFlag(process.env.PYB_PRUNE_EXECUTION_ENABLED);
+  if (explicit !== null) return explicit;
+  return false;
+}
+var resolvePruneExecutionEnabledForTest = resolvePruneExecutionEnabled;
 var SONNET_COST_PER_MILLION_INPUT_TOKENS = 3;
 var SONNET_COST_PER_MILLION_OUTPUT_TOKENS = 15;
 var SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS = 3.75;
@@ -1772,13 +2136,13 @@ var SONNET_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS = 0.3;
 var MAX_RETRIES = process.env.USER_TYPE === "SWE_BENCH" ? 100 : 10;
 var BASE_DELAY_MS = 500;
 function abortableDelay(delayMs, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new Error("Request was aborted"));
       return;
     }
     const timeoutId = setTimeout(() => {
-      resolve();
+      resolve2();
     }, delayMs);
     if (signal) {
       const abortHandler = () => {
@@ -2353,15 +2717,17 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
     );
   }
   const resolvedModel = modelProfile.modelName;
+  const toolUseContext = options.toolUseContext;
+  const pruneExecutionEnabled = resolvePruneExecutionEnabled(toolUseContext);
   const transformedMessages = transformMessagesForModel(
     messages,
     buildMessageTransformContext({
       source: "query",
       model: resolvedModel,
-      provider: modelProfile.provider || "openai"
+      provider: modelProfile.provider || "openai",
+      pruneExecutionEnabled
     })
   );
-  const toolUseContext = options.toolUseContext;
   if (toolUseContext && !toolUseContext.responseState) {
     const conversationId = getConversationId(
       toolUseContext.agentId,
@@ -2942,7 +3308,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
         start = Date.now();
         if (adapterContext) {
           if (adapterContext.shouldUseResponses) {
-            const { callGPT5ResponsesAPI } = await import("./openai-2V2J23AE.js");
+            const { callGPT5ResponsesAPI } = await import("./openai-XIRWQY5H.js");
             const response = await callGPT5ResponsesAPI(
               modelProfile,
               adapterContext.request,
@@ -3212,6 +3578,7 @@ export {
   queryQuick,
   refreshPybContext,
   resetAnthropicClient,
+  resolvePruneExecutionEnabledForTest,
   userMessageToMessageParam,
   verifyApiKey
 };