pybao-cli 1.4.83 → 1.4.84

package/dist/{file-MRX573XM.js → file-ULFXIDDG.js}

@@ -18,10 +18,10 @@ import {
   readFileSafe,
   readTextContent,
   writeTextContent
-} from "./chunk-FPCH7C5K.js";
-import "./chunk-KSCBNFN7.js";
-import "./chunk-VRRJXBF3.js";
-import "./chunk-GRQ32HWG.js";
+} from "./chunk-2Y6RSLIK.js";
+import "./chunk-TTMZXWQN.js";
+import "./chunk-BKU7DKGB.js";
+import "./chunk-LLNPRFDC.js";
 import "./chunk-I3J4JYES.js";
 export {
   addLineNumbers,

package/dist/index.js

@@ -2,7 +2,7 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   MACRO
-} from "./chunk-GRQ32HWG.js";
+} from "./chunk-LLNPRFDC.js";
 import "./chunk-I3J4JYES.js";
 
 // src/entrypoints/index.ts
@@ -28,7 +28,7 @@ Common options:
   process.exit(0);
 }
 if (hasFlag("--acp")) {
-  await import("./acp-5G23YRZD.js");
+  await import("./acp-KR2NIRMP.js");
 } else {
-  await import("./cli-7JVEUFE2.js");
+  await import("./cli-FHJDO3QF.js");
 }

package/dist/{llm-VAN6WS52.js → llm-WAAV3MBX.js}

@@ -4,34 +4,37 @@ import {
   getToolDescription
 } from "./chunk-XI4LTVYT.js";
 import {
+  emitTelemetryEvent,
   formatSystemPromptWithContext,
   generatePybContext,
   getCLISyspromptPrefix,
+  getModelCapabilities,
   getReasoningEffort,
   models_default,
-  refreshPybContext
-} from "./chunk-GKBRHNMB.js";
-import "./chunk-EINLEUKA.js";
-import "./chunk-WGGELTRR.js";
-import "./chunk-RMZABYAD.js";
+  refreshPybContext,
+  resolveModelResponsePolicy
+} from "./chunk-ZTGVZNCE.js";
+import "./chunk-SELNEWOV.js";
+import "./chunk-UZE4M5OS.js";
+import "./chunk-APXMGUKA.js";
 import "./chunk-F4AXICO7.js";
-import "./chunk-FQL6V43W.js";
-import "./chunk-A5LLPMGS.js";
+import "./chunk-NIIT2UQA.js";
+import "./chunk-4K65XDFQ.js";
 import "./chunk-5P7HBXTD.js";
-import "./chunk-5KEKIQVC.js";
-import "./chunk-IDJMJZP4.js";
+import "./chunk-KXHMHPXD.js";
+import "./chunk-3JI37ZA6.js";
 import {
   getCompletionWithProfile,
   getGPT5CompletionWithProfile
-} from "./chunk-53LVQG4V.js";
+} from "./chunk-KELCOTIO.js";
 import "./chunk-XKYHFZEC.js";
-import "./chunk-OUOB2RBI.js";
-import "./chunk-7UTUKVKM.js";
-import "./chunk-SUHM4MYA.js";
-import "./chunk-FVR53MZY.js";
+import "./chunk-5LRFEGFP.js";
+import "./chunk-6IXLNIBX.js";
+import "./chunk-ZPTG6OYN.js";
+import "./chunk-QUQAVKTY.js";
 import "./chunk-UNNVICVU.js";
-import "./chunk-5MZZCUQX.js";
-import "./chunk-DHJEENK5.js";
+import "./chunk-HS5IAPED.js";
+import "./chunk-RIKQVWEQ.js";
 import "./chunk-A3BVXXA3.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
@@ -42,7 +45,7 @@ import {
   PROMPT_TOO_LONG_ERROR_MESSAGE,
   createAssistantAPIErrorMessage,
   normalizeContentFromAPI
-} from "./chunk-EUHKG6AJ.js";
+} from "./chunk-4T65Y47N.js";
 import {
   processResponsesStream
 } from "./chunk-OMELVAJD.js";
@@ -53,27 +56,27 @@ import "./chunk-B6IMQJZM.js";
 import {
   addToTotalCost
 } from "./chunk-OUXHGDLH.js";
-import "./chunk-FPCH7C5K.js";
+import "./chunk-2Y6RSLIK.js";
 import "./chunk-QWIBSCDN.js";
-import "./chunk-XHQMUJIS.js";
-import "./chunk-CFX5VEY5.js";
-import "./chunk-5MEGIDN7.js";
+import "./chunk-X2MOC5KR.js";
+import "./chunk-CAPAA2BC.js";
+import "./chunk-UKCYPF74.js";
 import "./chunk-UZ34JEUK.js";
-import "./chunk-IIZXV4HL.js";
+import "./chunk-5EJDTTBL.js";
 import "./chunk-BJSWTHRM.js";
 import {
   USE_BEDROCK,
   USE_VERTEX,
   getModelManager,
   getVertexRegionForModel
-} from "./chunk-OCIKBYQ4.js";
-import "./chunk-MKSTJEGS.js";
-import "./chunk-KSCBNFN7.js";
-import "./chunk-TKPY5LGF.js";
+} from "./chunk-X36JZMFM.js";
+import "./chunk-SRT3X6FV.js";
+import "./chunk-TTMZXWQN.js";
+import "./chunk-5Z5ZS7IB.js";
 import {
   getAnthropicApiKey,
   getGlobalConfig
-} from "./chunk-WSP4AYLZ.js";
+} from "./chunk-QTPKDLLB.js";
 import "./chunk-RQVLBMP7.js";
 import {
   debug,
@@ -82,16 +85,16 @@ import {
   logLLMInteraction,
   logSystemPromptConstruction,
   markPhase
-} from "./chunk-MBIKKOOW.js";
+} from "./chunk-2OQK4SGM.js";
 import {
   PRODUCT_COMMAND,
   env,
   getCwd,
   logError
-} from "./chunk-VRRJXBF3.js";
+} from "./chunk-BKU7DKGB.js";
 import {
   MACRO
-} from "./chunk-GRQ32HWG.js";
+} from "./chunk-LLNPRFDC.js";
 import "./chunk-I3J4JYES.js";
 
 // src/services/ai/llm.ts
@@ -1169,151 +1172,6 @@ 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) {
@@ -1678,6 +1536,230 @@ function convertAnthropicMessagesToOpenAIMessages(messages) {
   return finalMessages;
 }
 
+// src/services/ai/messageTransform/policies.ts
+function resolvePolicies(context) {
+  return resolveModelResponsePolicy({
+    source: context.source,
+    model: context.model,
+    provider: context.provider,
+    reasoningPolicy: context.reasoningPolicy,
+    normalizeProviderContent: context.normalizeProviderContent,
+    trimCrossModelMetadata: context.trimCrossModelMetadata
+  });
+}
+
+// src/services/ai/messageTransform/providerRules.ts
+function createDefaultRuleHits() {
+  return {
+    trimmedMetadata: 0,
+    mappedReasoningBlocks: 0,
+    flattenedReasoningBlocks: 0,
+    filteredEmptyTextBlocks: 0,
+    filteredEmptyThinkingBlocks: 0
+  };
+}
+function applyProviderRules(messages, options) {
+  const ruleHits = createDefaultRuleHits();
+  const transformed = messages.map((message) => {
+    if (!message || typeof message !== "object" || !message.message) {
+      return message;
+    }
+    const sourceModel = String(message.message.model ?? "");
+    const shouldTrimMetadata = options.trimCrossModelMetadata && sourceModel.length > 0 && sourceModel !== options.model && message.message.providerMetadata && typeof message.message.providerMetadata === "object";
+    const content = message.message.content;
+    if (!Array.isArray(content)) {
+      if (!shouldTrimMetadata) return message;
+      const nextMessage2 = { ...message.message };
+      delete nextMessage2.providerMetadata;
+      ruleHits.trimmedMetadata += 1;
+      return { ...message, message: nextMessage2 };
+    }
+    let changed = false;
+    const mappedReasoning = [];
+    const nextContent = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        if (options.normalizeProviderContent) {
+          changed = true;
+          continue;
+        }
+        nextContent.push(block);
+        continue;
+      }
+      if (block.type === "text") {
+        const text = typeof block.text === "string" ? block.text : "";
+        if (options.normalizeProviderContent && text.trim().length === 0) {
+          changed = true;
+          ruleHits.filteredEmptyTextBlocks += 1;
+          continue;
+        }
+        nextContent.push(block);
+        continue;
+      }
+      if (block.type === "thinking" || block.type === "reasoning") {
+        const reasoningText = typeof block.thinking === "string" ? block.thinking : typeof block.reasoning === "string" ? block.reasoning : "";
+        if (options.normalizeProviderContent && reasoningText.trim().length === 0) {
+          changed = true;
+          ruleHits.filteredEmptyThinkingBlocks += 1;
+          continue;
+        }
+        if (options.reasoningPolicy === "map_to_provider_options") {
+          if (reasoningText.trim().length > 0) {
+            mappedReasoning.push(reasoningText.trim());
+          }
+          changed = true;
+          ruleHits.mappedReasoningBlocks += 1;
+          continue;
+        }
+        if (options.reasoningPolicy === "flatten_to_text_fallback") {
+          if (reasoningText.trim().length > 0) {
+            nextContent.push({ type: "text", text: reasoningText.trim() });
+          }
+          changed = true;
+          ruleHits.flattenedReasoningBlocks += 1;
+          continue;
+        }
+        if (block.type === "reasoning") {
+          nextContent.push({ type: "thinking", thinking: reasoningText });
+          changed = true;
+          continue;
+        }
+        nextContent.push(block);
+        continue;
+      }
+      nextContent.push(block);
+    }
+    const shouldMapReasoning = mappedReasoning.length > 0;
+    if (!changed && !shouldTrimMetadata && !shouldMapReasoning) {
+      return message;
+    }
+    const nextMessage = {
+      ...message.message,
+      content: nextContent
+    };
+    if (shouldTrimMetadata) {
+      delete nextMessage.providerMetadata;
+      ruleHits.trimmedMetadata += 1;
+    }
+    if (shouldMapReasoning) {
+      nextMessage.providerOptions = {
+        ...nextMessage.providerOptions || {},
+        reasoning_content: mappedReasoning.join("\n\n")
+      };
+    }
+    return {
+      ...message,
+      message: nextMessage
+    };
+  });
+  return { transformed, ruleHits };
+}
+
+// src/services/ai/messageTransform/index.ts
+var MESSAGE_TRANSFORM_RULE_VERSION = "b2-enhanced-v1";
+function collectBlockStats(messages) {
+  const stats = {};
+  for (const message of messages) {
+    const content = message?.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      const key = block && typeof block === "object" ? String(block.type ?? "unknown") : typeof block;
+      stats[key] = (stats[key] ?? 0) + 1;
+    }
+  }
+  return stats;
+}
+function transformMessagesForModel(messages, context) {
+  const resolved = resolvePolicies(context);
+  if (process.env.PYB_MESSAGE_TRANSFORM_ENABLED === "0") {
+    const payload2 = {
+      source: context.source,
+      model: context.model,
+      provider: context.provider,
+      dryRun: false,
+      reasoningPolicy: resolved.reasoningPolicy,
+      normalizeProviderContent: resolved.normalizeProviderContent,
+      trimCrossModelMetadata: resolved.trimCrossModelMetadata,
+      policySource: resolved.policySource,
+      ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
+      ruleHits: createDefaultRuleHits(),
+      reason: "disabled",
+      messageCount: messages.length,
+      outputBlockStats: collectBlockStats(messages)
+    };
+    debug.state("MESSAGE_TRANSFORM_SKIPPED", payload2);
+    emitTelemetryEvent({
+      channel: "message_transform",
+      phase: "MESSAGE_TRANSFORM_SKIPPED",
+      data: payload2,
+      timestamp: Date.now()
+    });
+    return messages;
+  }
+  const dryRun = process.env.PYB_MESSAGE_TRANSFORM_DRY_RUN === "1";
+  if (dryRun) {
+    const payload2 = {
+      source: context.source,
+      model: context.model,
+      provider: context.provider,
+      dryRun: true,
+      reasoningPolicy: resolved.reasoningPolicy,
+      normalizeProviderContent: resolved.normalizeProviderContent,
+      trimCrossModelMetadata: resolved.trimCrossModelMetadata,
+      policySource: resolved.policySource,
+      ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
+      ruleHits: createDefaultRuleHits(),
+      messageCount: messages.length,
+      outputBlockStats: collectBlockStats(messages)
+    };
+    debug.state("MESSAGE_TRANSFORM_APPLIED", payload2);
+    emitTelemetryEvent({
+      channel: "message_transform",
+      phase: "MESSAGE_TRANSFORM_APPLIED",
+      data: payload2,
+      timestamp: Date.now()
+    });
+    return messages;
+  }
+  const { transformed, ruleHits } = applyProviderRules(messages, {
+    model: context.model,
+    reasoningPolicy: resolved.reasoningPolicy,
+    normalizeProviderContent: resolved.normalizeProviderContent,
+    trimCrossModelMetadata: resolved.trimCrossModelMetadata
+  });
+  const payload = {
+    source: context.source,
+    model: context.model,
+    provider: context.provider,
+    dryRun: false,
+    reasoningPolicy: resolved.reasoningPolicy,
+    normalizeProviderContent: resolved.normalizeProviderContent,
+    trimCrossModelMetadata: resolved.trimCrossModelMetadata,
+    policySource: resolved.policySource,
+    ruleVersion: MESSAGE_TRANSFORM_RULE_VERSION,
+    ruleHits,
+    messageCount: messages.length,
+    outputBlockStats: collectBlockStats(transformed)
+  };
+  debug.state("MESSAGE_TRANSFORM_APPLIED", payload);
+  emitTelemetryEvent({
+    channel: "message_transform",
+    phase: "MESSAGE_TRANSFORM_APPLIED",
+    data: payload,
+    timestamp: Date.now()
+  });
+  return transformed;
+}
+
+// src/services/ai/messageTransform/context.ts
+function buildMessageTransformContext(params) {
+  return {
+    source: params.source,
+    model: params.model,
+    provider: params.provider ?? "openai"
+  };
+}
+
 // src/services/ai/llm.ts
 function isGPT5Model(modelName) {
   return modelName.startsWith("gpt-5");
@@ -2271,6 +2353,14 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
     );
   }
   const resolvedModel = modelProfile.modelName;
+  const transformedMessages = transformMessagesForModel(
+    messages,
+    buildMessageTransformContext({
+      source: "query",
+      model: resolvedModel,
+      provider: modelProfile.provider || "openai"
+    })
+  );
   const toolUseContext = options.toolUseContext;
   if (toolUseContext && !toolUseContext.responseState) {
     const conversationId = getConversationId(
@@ -2294,7 +2384,7 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
   });
   const currentRequest = getCurrentRequest();
   debug.api("LLM_REQUEST_START", {
-    messageCount: messages.length,
+    messageCount: transformedMessages.length,
     systemPromptLength: systemPrompt.join(" ").length,
     toolCount: tools.length,
     model: resolvedModel,
@@ -2308,7 +2398,7 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
     delete cleanOptions.__testModelManager;
     delete cleanOptions.__testQueryLLMWithPromptCaching;
     const runQuery = () => queryFn(
-      messages,
+      transformedMessages,
       systemPrompt,
       maxThinkingTokens,
       tools,
@@ -2320,7 +2410,7 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
         toolUseContext
       }
     );
-    const result = options.__testQueryLLMWithPromptCaching ? await runQuery() : await withVCR(messages, runQuery);
+    const result = options.__testQueryLLMWithPromptCaching ? await runQuery() : await withVCR(transformedMessages, runQuery);
     debug.api("LLM_REQUEST_SUCCESS", {
       costUSD: result.costUSD,
       durationMs: result.durationMs,
@@ -2343,7 +2433,7 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
     logErrorWithDiagnosis(
       error,
       {
-        messageCount: messages.length,
+        messageCount: transformedMessages.length,
         systemPromptLength: systemPrompt.join(" ").length,
         model: options.model,
         toolCount: tools.length,
@@ -2852,7 +2942,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
         start = Date.now();
         if (adapterContext) {
           if (adapterContext.shouldUseResponses) {
-            const { callGPT5ResponsesAPI } = await import("./openai-WTOKA74W.js");
+            const { callGPT5ResponsesAPI } = await import("./openai-7OC7CIDJ.js");
             const response = await callGPT5ResponsesAPI(
               modelProfile,
               adapterContext.request,