newcraw 1.0.2 → 1.0.4

package/dist/{llm-CYUDKJNR.js → llm-OJZ6DZVC.js}

@@ -3,45 +3,49 @@ const require = __newcrawCreateRequire(import.meta.url);
 import {
   getToolDescription
 } from "./chunk-T25Z3JMG.js";
+import {
+  isProviderAvailable,
+  markProviderFailure,
+  markProviderSuccess,
+  selectAvailableProvider
+} from "./chunk-2BVCVKKB.js";
 import {
   processResponsesStream
 } from "./chunk-BHNQGSLO.js";
+import {
+  structuredOutputConfig
+} from "./chunk-BQCOSNM3.js";
 import {
   formatSystemPromptWithContext,
-  generateKodeContext,
-  getCLISyspromptPrefix,
-  getReasoningEffort,
-  models_default,
-  refreshKodeContext
-} from "./chunk-OJIMOLIC.js";
-import "./chunk-XS6PU75S.js";
-import "./chunk-WWDVA4NV.js";
-import "./chunk-VQSCECTS.js";
-import "./chunk-HSJ6HYAO.js";
-import "./chunk-3LMXSKZ7.js";
-import "./chunk-XXU2NVOE.js";
+  getCLISyspromptPrefix
+} from "./chunk-3CKC4ABU.js";
+import {
+  models_default
+} from "./chunk-Q2OBTLBI.js";
+import "./chunk-UPRKGNBR.js";
+import "./chunk-NFXLN6FJ.js";
+import "./chunk-IVWPPTDM.js";
+import "./chunk-KJTPUTU7.js";
 import "./chunk-JX5ZQYTQ.js";
 import {
   setRequestStatus
 } from "./chunk-XJQATPV7.js";
-import "./chunk-V5U6BHT2.js";
-import "./chunk-7ZFLZNOW.js";
-import "./chunk-VHS2MZQS.js";
 import {
   getCompletionWithProfile,
   getGPT5CompletionWithProfile
-} from "./chunk-QH2M65BR.js";
-import "./chunk-RUXIBQ3B.js";
-import "./chunk-JWXQNBBA.js";
-import "./chunk-2C43OXE7.js";
-import "./chunk-BWYKUDJR.js";
-import "./chunk-2EFL22PV.js";
+} from "./chunk-MUW3J7CP.js";
+import {
+  getReasoningEffort
+} from "./chunk-MMF5RMLU.js";
+import "./chunk-BJYXLCRS.js";
+import "./chunk-QJ7MQIHN.js";
+import "./chunk-IZZTKEZH.js";
+import "./chunk-UUCRNFMH.js";
+import "./chunk-X3NER6FY.js";
 import "./chunk-U7S4MEYP.js";
-import "./chunk-UYRR6F5S.js";
+import "./chunk-FIMCETCB.js";
 import "./chunk-TY3CCSAT.js";
-import "./chunk-LOIZNQOU.js";
-import "./chunk-INJSFEKL.js";
-import "./chunk-2UO3BFZH.js";
+import "./chunk-ZM5FMRLS.js";
 import {
   API_ERROR_MESSAGE_PREFIX,
   CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
@@ -51,41 +55,67 @@ import {
   PROMPT_TOO_LONG_ERROR_MESSAGE,
   createAssistantAPIErrorMessage,
   normalizeContentFromAPI
-} from "./chunk-A7X6OCZE.js";
+} from "./chunk-IXFBUXQW.js";
+import "./chunk-WAXMRSVR.js";
+import "./chunk-MJLWBVZP.js";
+import "./chunk-KS646CDL.js";
+import "./chunk-7ZFLZNOW.js";
+import "./chunk-W7Q3VYAB.js";
+import "./chunk-INJSFEKL.js";
+import "./chunk-JI4HCLK7.js";
+import "./chunk-JLVECHVJ.js";
+import "./chunk-2JCTO2EY.js";
+import "./chunk-2UO3BFZH.js";
+import "./chunk-CHB5K4GI.js";
 import {
   USE_BEDROCK,
   USE_VERTEX,
   getModelManager,
-  getVertexRegionForModel
-} from "./chunk-F3COCCAE.js";
-import "./chunk-53A4JHFW.js";
-import "./chunk-DEF3KFP7.js";
+  getVertexRegionForModel,
+  init_model
+} from "./chunk-QX5Y5CE5.js";
+import {
+  getProjectDocs
+} from "./chunk-MJ3MLGVB.js";
+import "./chunk-GVLJUD6R.js";
 import {
   getAnthropicApiKey,
-  getGlobalConfig
-} from "./chunk-IIFUDVGS.js";
-import "./chunk-KQSHIOZK.js";
+  getGlobalConfig,
+  init_config
+} from "./chunk-U6IF5D3J.js";
+import "./chunk-NT7RDVDA.js";
 import {
   debug,
   getCurrentRequest,
+  init_debugLogger,
   logErrorWithDiagnosis,
   logLLMInteraction,
   logSystemPromptConstruction,
   markPhase
-} from "./chunk-GZTCXXSS.js";
+} from "./chunk-QT5GS374.js";
 import {
-  PRODUCT_COMMAND,
   env,
   getCwd,
+  init_env,
+  init_log,
+  init_state,
   logError
-} from "./chunk-IM33F5CM.js";
+} from "./chunk-XYQZLDRB.js";
 import {
-  MACRO
-} from "./chunk-ZYSVG4X3.js";
+  PRODUCT_COMMAND,
+  init_product
+} from "./chunk-UYWZQVH5.js";
+import {
+  MACRO,
+  init_macros
+} from "./chunk-EHQ2M5B4.js";
 import {
   addToTotalCost
-} from "./chunk-755HIAI3.js";
-import "./chunk-AXWJI6N5.js";
+} from "./chunk-ZMO4E7IW.js";
+import "./chunk-HLBLZKZH.js";
+import {
+  __require
+} from "./chunk-D4OZACS2.js";
 
 // src/services/ai/llm.ts
 import "@anthropic-ai/sdk/shims/node";
@@ -95,11 +125,17 @@ import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
 import chalk from "chalk";
 import { randomUUID } from "crypto";
 import "dotenv/config";
+init_config();
+init_log();
 
 // src/utils/system/http.ts
+init_macros();
+init_product();
 var USER_AGENT = `${PRODUCT_COMMAND}/${MACRO.VERSION} (${process.env.USER_TYPE})`;
 
 // src/services/system/vcr.ts
+init_env();
+init_state();
 import { createHash } from "crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname } from "path";
@@ -229,6 +265,8 @@ function hydrateValue(s) {
 }
 
 // src/services/ai/llm.ts
+init_debugLogger();
+init_model();
 import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
 
 // src/services/ai/adapters/base.ts
@@ -295,6 +333,8 @@ var ModelAPIAdapter = class {
 };
 
 // src/services/ai/adapters/openaiAdapter.ts
+init_debugLogger();
+init_log();
 import { zodToJsonSchema } from "zod-to-json-schema";
 var OpenAIAdapter = class extends ModelAPIAdapter {
   constructor(capabilities, modelProfile) {
@@ -465,6 +505,8 @@ var OpenAIAdapter = class extends ModelAPIAdapter {
 
 // src/services/ai/adapters/responsesAPI.ts
 import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+init_debugLogger();
+init_log();
 var ResponsesAPIAdapter = class extends OpenAIAdapter {
   createRequest(params) {
     const {
@@ -530,6 +572,8 @@ var ResponsesAPIAdapter = class extends OpenAIAdapter {
     return request;
   }
   buildTools(tools) {
+    const provider = this.modelProfile.provider || "openai";
+    const config = structuredOutputConfig(provider);
     return tools.map((tool) => {
       let parameters = tool.inputJSONSchema;
       if (!parameters && tool.inputSchema) {
@@ -555,7 +599,8 @@ var ResponsesAPIAdapter = class extends OpenAIAdapter {
         type: "function",
         name: tool.name,
         description: getToolDescription(tool),
-        parameters: parameters || { type: "object", properties: {} }
+        parameters: parameters || { type: "object", properties: {} },
+        ...config.enableStrictTools ? { strict: true } : {}
       };
     });
   }
@@ -715,7 +760,7 @@ ${reasoningContent}
     return state;
   }
   async parseStreamingOpenAIResponse(response) {
-    const { processResponsesStream: processResponsesStream2 } = await import("./responsesStreaming-2AIT6GHG.js");
+    const { processResponsesStream: processResponsesStream2 } = await import("./responsesStreaming-JORGEFQC.js");
     return await processResponsesStream2(
       this.parseStreamingResponse(response),
       Date.now(),
@@ -915,12 +960,15 @@ var ChatCompletionsAdapter = class extends OpenAIAdapter {
     return request;
   }
   buildTools(tools) {
+    const provider = this.modelProfile.provider || "openai";
+    const config = structuredOutputConfig(provider);
     return tools.map((tool) => ({
       type: "function",
       function: {
         name: tool.name,
         description: getToolDescription(tool),
-        parameters: tool.inputJSONSchema || zodToJsonSchema3(tool.inputSchema)
+        parameters: tool.inputJSONSchema || zodToJsonSchema3(tool.inputSchema),
+        ...config.enableStrictTools ? { strict: true } : {}
       }
     }));
   }
@@ -1389,6 +1437,8 @@ function getConversationId(agentId, messageId) {
 }
 
 // src/services/ai/llm.ts
+init_model();
+init_model();
 import { nanoid } from "nanoid";
 
 // src/utils/tooling/toolUsePartialJson.ts
@@ -1673,6 +1723,70 @@ function convertAnthropicMessagesToOpenAIMessages(messages) {
   return finalMessages;
 }
 
+// src/services/context/kodeContext.ts
+init_debugLogger();
+init_log();
+var KodeContextManager = class _KodeContextManager {
+  static instance;
+  projectDocsCache = "";
+  cacheInitialized = false;
+  initPromise = null;
+  static getInstance() {
+    if (!_KodeContextManager.instance) {
+      _KodeContextManager.instance = new _KodeContextManager();
+    }
+    return _KodeContextManager.instance;
+  }
+  async initialize() {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        const projectDocs = await getProjectDocs();
+        this.projectDocsCache = projectDocs || "";
+        this.cacheInitialized = true;
+      } catch (error) {
+        logError(error);
+        debug.warn("NEWCRAW_CONTEXT_LOAD_FAILED", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        this.projectDocsCache = "";
+        this.cacheInitialized = true;
+      }
+    })();
+    return this.initPromise;
+  }
+  getKodeContext() {
+    if (!this.cacheInitialized) {
+      this.initialize().catch((error) => {
+        logError(error);
+        debug.warn("NEWCRAW_CONTEXT_LOAD_FAILED", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+      return "";
+    }
+    return this.projectDocsCache;
+  }
+  async refreshCache() {
+    this.cacheInitialized = false;
+    this.initPromise = null;
+    await this.initialize();
+  }
+};
+var kodeContextManager = KodeContextManager.getInstance();
+var generateKodeContext = () => {
+  return kodeContextManager.getKodeContext();
+};
+var refreshKodeContext = async () => {
+  await kodeContextManager.refreshCache();
+};
+if (process.env.NODE_ENV !== "test") {
+  setTimeout(() => {
+    refreshKodeContext().catch(() => {
+    });
+  }, 0);
+}
+
 // src/services/ai/llm.ts
 function isGPT5Model(modelName) {
   return modelName.startsWith("gpt-5");
@@ -2016,7 +2130,33 @@ async function handleMessageStream(stream, signal) {
     usage
   };
 }
-function convertOpenAIResponseToAnthropic(response, tools) {
+var ToolCallParseError = class extends Error {
+  constructor(toolName, rawArguments, parseError) {
+    super(`Failed to parse tool call arguments for "${toolName}": ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    this.toolName = toolName;
+    this.rawArguments = rawArguments;
+    this.parseError = parseError;
+    this.name = "ToolCallParseError";
+  }
+};
+function validateToolArgsWithSchema(toolArgs, toolDef) {
+  if (!toolDef) return { valid: true };
+  const schema = toolDef.inputSchema ?? toolDef.input_schema;
+  if (!schema || typeof schema !== "object") return { valid: true };
+  try {
+    const Ajv = __require("ajv");
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    const validate = ajv.compile(schema);
+    const valid = validate(toolArgs);
+    if (!valid && validate.errors) {
+      const errMsg = validate.errors.map((e) => `${e.instancePath || "/"}: ${e.message}`).join("; ");
+      return { valid: false, errors: errMsg };
+    }
+  } catch {
+  }
+  return { valid: true };
+}
+function convertOpenAIResponseToAnthropic(response, tools, options) {
   let contentBlocks = [];
   const message = response.choices?.[0]?.message;
   if (!message) {
@@ -2036,6 +2176,20 @@ function convertOpenAIResponseToAnthropic(response, tools) {
       try {
         toolArgs = tool?.arguments ? JSON.parse(tool.arguments) : {};
       } catch (e) {
+        if (options?.throwOnParseError) {
+          throw new ToolCallParseError(toolName ?? "unknown", tool?.arguments ?? "", e);
+        }
+      }
+      if (options?.postValidate && Object.keys(toolArgs).length > 0) {
+        const matchedTool = tools?.find((t) => t.name === toolName);
+        const validation = validateToolArgsWithSchema(toolArgs, matchedTool);
+        if (!validation.valid && options?.throwOnParseError) {
+          throw new ToolCallParseError(
+            toolName ?? "unknown",
+            tool?.arguments ?? "",
+            new Error(`AJV validation failed: ${validation.errors}`)
+          );
+        }
       }
       contentBlocks.push({
         type: "tool_use",
@@ -2349,13 +2503,37 @@ async function queryLLMWithPromptCaching(messages, systemPrompt, maxThinkingToke
   const config = getGlobalConfig();
   const modelManager = getModelManager();
   const toolUseContext = options.toolUseContext;
-  const modelProfile = options.modelProfile || modelManager.getModel("main");
+  let modelProfile = options.modelProfile || modelManager.getModel("main");
   let provider;
   if (modelProfile) {
     provider = modelProfile.provider || config.primaryProvider || "anthropic";
   } else {
     provider = config.primaryProvider || "anthropic";
   }
+  if (!isProviderAvailable(provider)) {
+    const allProfiles = [
+      modelManager.getModel("main"),
+      modelManager.getModel("task"),
+      modelManager.getModel("quick")
+    ].filter((p) => !!p && p.provider !== provider);
+    const fallbackProviders = [...new Set(allProfiles.map((p) => p.provider))];
+    const selected = selectAvailableProvider({
+      primary: provider,
+      fallbacks: fallbackProviders
+    });
+    if (selected && selected !== provider) {
+      const fallbackProfile = allProfiles.find((p) => p.provider === selected);
+      if (fallbackProfile) {
+        debug.warn("PROVIDER_FAILOVER_ACTIVATED", {
+          from: provider,
+          to: selected,
+          model: fallbackProfile.modelName
+        });
+        provider = selected;
+        modelProfile = fallbackProfile;
+      }
+    }
+  }
   if (provider === "anthropic" || provider === "bigdream" || provider === "opendev" || provider === "minimax-coding") {
     return queryAnthropicNative(
       messages,
@@ -2699,8 +2877,10 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
     const costUSD = inputTokens / 1e6 * getModelInputTokenCostUSD(model) + outputTokens / 1e6 * getModelOutputTokenCostUSD(model) + cacheCreationInputTokens / 1e6 * getModelInputTokenCostUSD(model) + cacheReadInputTokens / 1e6 * (getModelInputTokenCostUSD(model) * 0.1);
     assistantMessage.costUSD = costUSD;
     addToTotalCost(costUSD, durationMs);
+    markProviderSuccess(provider, durationMs);
     return assistantMessage;
   } catch (error) {
+    markProviderFailure(provider, error instanceof Error ? error.message : String(error));
     return getAssistantMessageFromError(error);
   }
 }
@@ -2766,18 +2946,26 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
       type: "text"
     })
   );
+  const provider = modelProfile?.provider || config.primaryProvider || "openai";
+  const { structuredOutputConfig: getStructuredConfig } = await import("./structuredOutput-KAVFUV2Z.js");
+  const structuredConfig = getStructuredConfig(provider);
   const toolSchemas = await Promise.all(
     tools.map(
-      async (_) => ({
-        type: "function",
-        function: {
-          name: _.name,
-          description: await _.prompt({
-            safeMode: options?.safeMode
-          }),
-          parameters: "inputJSONSchema" in _ && _.inputJSONSchema ? _.inputJSONSchema : zodToJsonSchema4(_.inputSchema)
-        }
-      })
+      async (_) => {
+        const parameters = "inputJSONSchema" in _ && _.inputJSONSchema ? _.inputJSONSchema : zodToJsonSchema4(_.inputSchema);
+        const toolDef = {
+          type: "function",
+          function: {
+            name: _.name,
+            description: await _.prompt({
+              safeMode: options?.safeMode
+            }),
+            parameters,
+            ...structuredConfig.enableStrictTools ? { strict: true } : {}
+          }
+        };
+        return toolDef;
+      }
     )
   );
   const openaiSystem = system.map(
@@ -2837,13 +3025,17 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
   }
   let queryResult;
   let startIncludingRetries = Date.now();
-  try {
-    queryResult = await withRetry(
+  const toolCallMaxRetries = structuredConfig.maxRetries;
+  const isPostValidateMode = structuredConfig.mode === "post_validate";
+  let throwOnToolParseError = true;
+  const executeQuery = async () => {
+    const shouldThrowOnParse = throwOnToolParseError;
+    return withRetry(
       async () => {
         start = Date.now();
         if (adapterContext) {
           if (adapterContext.shouldUseResponses) {
-            const { callGPT5ResponsesAPI } = await import("./openai-KTZV6F7N.js");
+            const { callGPT5ResponsesAPI } = await import("./openai-SMYIAIO4.js");
             const response = await callGPT5ResponsesAPI(
               modelProfile,
               adapterContext.request,
@@ -2879,7 +3071,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
           } else {
             finalResponse2 = s2;
           }
-          const message2 = convertOpenAIResponseToAnthropic(finalResponse2, tools);
+          const message2 = convertOpenAIResponseToAnthropic(finalResponse2, tools, { throwOnParseError: shouldThrowOnParse, postValidate: isPostValidateMode });
           const assistantMsg2 = {
             type: "assistant",
             message: message2,
@@ -2915,6 +3107,30 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
         if (toolSchemas.length > 0) {
           opts.tools = toolSchemas;
           opts.tool_choice = "auto";
+          if (structuredConfig.mode === "format_json") {
+            ;
+            opts.format = "json";
+          } else if (structuredConfig.mode === "guided_json" && toolSchemas.length > 0) {
+            const toolParamSchemas = toolSchemas.map((t) => t.function?.parameters).filter(Boolean);
+            if (toolParamSchemas.length > 0) {
+              ;
+              opts.guided_json = toolParamSchemas[0];
+            }
+          } else if (structuredConfig.mode === "strict" && !config.stream) {
+            const firstToolSchema = toolSchemas[0];
+            const paramSchema = firstToolSchema?.function?.parameters;
+            if (paramSchema) {
+              ;
+              opts.response_format = {
+                type: "json_schema",
+                json_schema: {
+                  name: "tool_call_output",
+                  strict: true,
+                  schema: paramSchema
+                }
+              };
+            }
+          }
         }
         const reasoningEffort = await getReasoningEffort(modelProfile, messages);
         if (reasoningEffort) {
@@ -2931,7 +3147,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
         } else {
           finalResponse = s;
         }
-        const message = convertOpenAIResponseToAnthropic(finalResponse, tools);
+        const message = convertOpenAIResponseToAnthropic(finalResponse, tools, { throwOnParseError: shouldThrowOnParse, postValidate: isPostValidateMode });
         const assistantMsg = {
           type: "assistant",
           message,
@@ -2947,7 +3163,36 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
       },
       { signal }
     );
+  };
+  try {
+    for (let attempt = 0; attempt <= toolCallMaxRetries; attempt++) {
+      try {
+        queryResult = await executeQuery();
+        break;
+      } catch (error) {
+        if (error instanceof ToolCallParseError && attempt < toolCallMaxRetries) {
+          debug.warn("TOOL_CALL_PARSE_RETRY", {
+            toolName: error.toolName,
+            attempt: attempt + 1,
+            maxRetries: toolCallMaxRetries,
+            rawArgs: error.rawArguments.slice(0, 200)
+          });
+          continue;
+        }
+        if (error instanceof ToolCallParseError) {
+          debug.warn("TOOL_CALL_PARSE_EXHAUSTED", {
+            toolName: error.toolName,
+            rawArgs: error.rawArguments.slice(0, 200)
+          });
+          throwOnToolParseError = false;
+          queryResult = await executeQuery();
+          break;
+        }
+        throw error;
+      }
+    }
   } catch (error) {
+    markProviderFailure(provider, error instanceof Error ? error.message : String(error));
     logError(error);
     return getAssistantMessageFromError(error);
   }
@@ -2965,6 +3210,7 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
   const cacheCreationInputTokens = normalizedUsage.cache_creation_input_tokens ?? 0;
   const costUSD = inputTokens / 1e6 * SONNET_COST_PER_MILLION_INPUT_TOKENS + outputTokens / 1e6 * SONNET_COST_PER_MILLION_OUTPUT_TOKENS + cacheReadInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS + cacheCreationInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS;
   addToTotalCost(costUSD, durationMsIncludingRetries);
+  markProviderSuccess(provider, durationMs);
   logLLMInteraction({
     systemPrompt: systemPrompt.join("\n"),
     messages: [...openaiSystem, ...openaiMessages],