@within-7/minto 0.1.4 → 0.1.6

package/dist/services/claude.js

@@ -14,6 +14,7 @@ import {
 } from "../utils/config.js";
 import { getProjectDocs } from "../context.js";
 import { logError, SESSION_ID } from "../utils/log.js";
+import { abortableDelay } from "../utils/async.js";
 import { USER_AGENT } from "../utils/http.js";
 import {
   createAssistantAPIErrorMessage,
@@ -36,41 +37,15 @@ import { USE_BEDROCK, USE_VERTEX } from "../utils/model.js";
 import { getCLISyspromptPrefix } from "../constants/prompts.js";
 import { getVertexRegionForModel } from "../utils/model.js";
 import { nanoid } from "nanoid";
-import { getCompletionWithProfile, getGPT5CompletionWithProfile } from "./openai.js";
+import {
+  getCompletionWithProfile,
+  getGPT5CompletionWithProfile
+} from "./openai.js";
 import { getReasoningEffort } from "../utils/thinking.js";
 import { generateSystemReminders } from "./systemReminder.js";
 function isGPT5Model(modelName) {
   return modelName.startsWith("gpt-5");
 }
-function getModelConfigForDebug(model) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const modelProfile = modelManager.getModel("main");
-  let apiKeyStatus = "missing";
-  let baseURL;
-  let maxTokens;
-  let reasoningEffort;
-  if (modelProfile) {
-    apiKeyStatus = modelProfile.apiKey ? "configured" : "missing";
-    baseURL = modelProfile.baseURL;
-    maxTokens = modelProfile.maxTokens;
-    reasoningEffort = modelProfile.reasoningEffort;
-  } else {
-    apiKeyStatus = "missing";
-    maxTokens = void 0;
-    reasoningEffort = void 0;
-  }
-  return {
-    modelName: model,
-    provider: modelProfile?.provider || config.primaryProvider || "anthropic",
-    apiKeyStatus,
-    baseURL,
-    maxTokens,
-    reasoningEffort,
-    isStream: config.stream || false,
-    temperature: MAIN_QUERY_TEMPERATURE
-  };
-}
 class MintoContextManager {
   static instance;
   projectDocsCache = "";
@@ -103,14 +78,15 @@ class MintoContextManager {
         });
       }
     } catch (error) {
-      console.warn("[MintoContext] Failed to load project docs:", error);
+      debugLogger.warn("MINTO_CONTEXT_LOAD_FAILED", { error: String(error) });
       this.projectDocsCache = "";
       this.cacheInitialized = true;
     }
   }
   getMintoContext() {
     if (!this.cacheInitialized) {
-      this.initialize().catch(console.warn);
+      this.initialize().catch(() => {
+      });
       return "";
     }
     return this.projectDocsCache;
@@ -122,7 +98,8 @@ class MintoContextManager {
   }
 }
 const mintoContextManager = MintoContextManager.getInstance();
-mintoContextManager.initialize().catch(console.warn);
+mintoContextManager.initialize().catch(() => {
+});
 const generateMintoContext = () => {
   return mintoContextManager.getMintoContext();
 };
@@ -135,10 +112,6 @@ const CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE = "Credit balance is too low";
 const INVALID_API_KEY_ERROR_MESSAGE = "Invalid API key \xB7 Please run /login";
 const NO_CONTENT_MESSAGE = "(no content)";
 const PROMPT_CACHING_ENABLED = !process.env.DISABLE_PROMPT_CACHING;
-const HAIKU_COST_PER_MILLION_INPUT_TOKENS = 0.8;
-const HAIKU_COST_PER_MILLION_OUTPUT_TOKENS = 4;
-const HAIKU_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS = 1;
-const HAIKU_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS = 0.08;
 const SONNET_COST_PER_MILLION_INPUT_TOKENS = 3;
 const SONNET_COST_PER_MILLION_OUTPUT_TOKENS = 15;
 const SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS = 3.75;
@@ -151,24 +124,6 @@ function getMetadata() {
 }
 const MAX_RETRIES = process.env.USER_TYPE === "SWE_BENCH" ? 100 : 10;
 const BASE_DELAY_MS = 500;
-function abortableDelay(delayMs, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Request was aborted"));
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      resolve();
-    }, delayMs);
-    if (signal) {
-      const abortHandler = () => {
-        clearTimeout(timeoutId);
-        reject(new Error("Request was aborted"));
-      };
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-  });
-}
 function getRetryDelay(attempt, retryAfterHeader) {
   if (retryAfterHeader) {
     const seconds = parseInt(retryAfterHeader, 10);
@@ -266,7 +221,7 @@ async function fetchAnthropicModels(baseURL, apiKey) {
     if (error instanceof Error && error.message.includes("API key") || error instanceof Error && error.message.includes("Anthropic")) {
       throw error;
     }
-    console.error("Failed to fetch Anthropic models:", error);
+    logError(error);
     throw new Error(
       "Unable to connect to Anthropic API. Please check your internet connection and try again."
     );
@@ -283,9 +238,9 @@ async function verifyApiKey(apiKey, baseURL, provider) {
         "Content-Type": "application/json"
       };
       if (!baseURL) {
-        console.warn(
-          "No baseURL provided for non-Anthropic provider verification"
-        );
+        debugLogger.warn("API_VERIFY", {
+          error: "No baseURL provided for non-Anthropic provider"
+        });
         return false;
       }
       const modelsURL = `${baseURL.replace(/\/+$/, "")}/models`;
@@ -295,7 +250,10 @@ async function verifyApiKey(apiKey, baseURL, provider) {
       });
       return response.ok;
     } catch (error) {
-      console.warn("API verification failed for non-Anthropic provider:", error);
+      debugLogger.warn("API_VERIFY", {
+        error: "non-Anthropic provider verification failed",
+        details: String(error)
+      });
       return false;
     }
   }
@@ -537,7 +495,7 @@ async function handleMessageStream(stream, signal) {
     usage
   };
 }
-function convertOpenAIResponseToAnthropic(response, tools) {
+function convertOpenAIResponseToAnthropic(response, _tools) {
   let contentBlocks = [];
   const message = response.choices?.[0]?.message;
   if (!message) {
@@ -671,7 +629,7 @@ function applyCacheControlWithLimits(systemBlocks, messageParams) {
   }
   const maxCacheBlocks = 4;
   let usedCacheBlocks = 0;
-  const processedSystemBlocks = systemBlocks.map((block, index) => {
+  const processedSystemBlocks = systemBlocks.map((block, _index) => {
     if (usedCacheBlocks < maxCacheBlocks && block.text.length > 1e3) {
       usedCacheBlocks++;
       return {
@@ -684,20 +642,22 @@ function applyCacheControlWithLimits(systemBlocks, messageParams) {
   });
   const processedMessageParams = messageParams.map((message, messageIndex) => {
     if (Array.isArray(message.content)) {
-      const processedContent = message.content.map((contentBlock, blockIndex) => {
-        const shouldCache = usedCacheBlocks < maxCacheBlocks && contentBlock.type === "text" && typeof contentBlock.text === "string" && // Long documents (over 2000 characters)
-        (contentBlock.text.length > 2e3 || // Last content block of the last message (may be important context)
-        messageIndex === messageParams.length - 1 && blockIndex === message.content.length - 1 && contentBlock.text.length > 500);
-        if (shouldCache) {
-          usedCacheBlocks++;
-          return {
-            ...contentBlock,
-            cache_control: { type: "ephemeral" }
-          };
+      const processedContent = message.content.map(
+        (contentBlock, blockIndex) => {
+          const shouldCache = usedCacheBlocks < maxCacheBlocks && contentBlock.type === "text" && typeof contentBlock.text === "string" && // Long documents (over 2000 characters)
+          (contentBlock.text.length > 2e3 || // Last content block of the last message (may be important context)
+          messageIndex === messageParams.length - 1 && blockIndex === message.content.length - 1 && contentBlock.text.length > 500);
+          if (shouldCache) {
+            usedCacheBlocks++;
+            return {
+              ...contentBlock,
+              cache_control: { type: "ephemeral" }
+            };
+          }
+          const { cache_control, ...blockWithoutCache } = contentBlock;
+          return blockWithoutCache;
         }
-        const { cache_control, ...blockWithoutCache } = contentBlock;
-        return blockWithoutCache;
-      });
+      );
       return {
         ...message,
         content: processedContent
@@ -775,7 +735,10 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
   const resolvedModel = modelProfile.modelName;
   const toolUseContext = options.toolUseContext;
   if (toolUseContext && !toolUseContext.responseState) {
-    const conversationId = getConversationId(toolUseContext.agentId, toolUseContext.messageId);
+    const conversationId = getConversationId(
+      toolUseContext.agentId,
+      toolUseContext.messageId
+    );
     const previousResponseId = responseStateManager.getPreviousResponseId(conversationId);
     toolUseContext.responseState = {
       previousResponseId,
@@ -1009,146 +972,26 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
   let attemptNumber = 0;
   let response;
   try {
-    response = await withRetry(async (attempt) => {
-      attemptNumber = attempt;
-      start = Date.now();
-      const params = {
-        model,
-        max_tokens: getMaxTokensFromProfile(modelProfile),
-        messages: processedMessages,
-        system: processedSystem,
-        tools: toolSchemas.length > 0 ? toolSchemas : void 0,
-        tool_choice: toolSchemas.length > 0 ? { type: "auto" } : void 0
-      };
-      if (maxThinkingTokens > 0) {
-        ;
-        params.extra_headers = {
-          "anthropic-beta": "max-tokens-3-5-sonnet-2024-07-15"
+    response = await withRetry(
+      async (attempt) => {
+        attemptNumber = attempt;
+        start = Date.now();
+        const params = {
+          model,
+          max_tokens: getMaxTokensFromProfile(modelProfile),
+          messages: processedMessages,
+          system: processedSystem,
+          tools: toolSchemas.length > 0 ? toolSchemas : void 0,
+          tool_choice: toolSchemas.length > 0 ? { type: "auto" } : void 0
         };
-        params.thinking = { max_tokens: maxThinkingTokens };
-      }
-      debugLogger.api("ANTHROPIC_API_CALL_START_STREAMING", {
-        endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
-        model,
-        provider,
-        apiKeyConfigured: !!modelProfile?.apiKey,
-        apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
-        maxTokens: params.max_tokens,
-        temperature: MAIN_QUERY_TEMPERATURE,
-        params,
-        messageCount: params.messages?.length || 0,
-        streamMode: true,
-        toolsCount: toolSchemas.length,
-        thinkingTokens: maxThinkingTokens,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        modelProfileId: modelProfile?.modelName,
-        modelProfileName: modelProfile?.name
-      });
-      if (config.stream) {
-        const stream = await anthropic.beta.messages.create({
-          ...params,
-          stream: true
-        }, {
-          signal
-          // ← CRITICAL: Connect the AbortSignal to API call
-        });
-        let finalResponse = null;
-        let messageStartEvent = null;
-        const contentBlocks = [];
-        const inputJSONBuffers = /* @__PURE__ */ new Map();
-        let usage = null;
-        let stopReason = null;
-        let stopSequence = null;
-        for await (const event of stream) {
-          if (signal.aborted) {
-            debugLogger.flow("STREAM_ABORTED", {
-              eventType: event.type,
-              timestamp: Date.now()
-            });
-            throw new Error("Request was cancelled");
-          }
-          switch (event.type) {
-            case "message_start":
-              messageStartEvent = event;
-              finalResponse = {
-                ...event.message,
-                content: []
-                // Will be populated from content blocks
-              };
-              break;
-            case "content_block_start":
-              contentBlocks[event.index] = { ...event.content_block };
-              if (event.content_block.type === "tool_use") {
-                inputJSONBuffers.set(event.index, "");
-              }
-              break;
-            case "content_block_delta":
-              const blockIndex = event.index;
-              if (!contentBlocks[blockIndex]) {
-                contentBlocks[blockIndex] = {
-                  type: event.delta.type === "text_delta" ? "text" : "tool_use",
-                  text: event.delta.type === "text_delta" ? "" : void 0
-                };
-                if (event.delta.type === "input_json_delta") {
-                  inputJSONBuffers.set(blockIndex, "");
-                }
-              }
-              if (event.delta.type === "text_delta") {
-                contentBlocks[blockIndex].text += event.delta.text;
-              } else if (event.delta.type === "input_json_delta") {
-                const currentBuffer = inputJSONBuffers.get(blockIndex) || "";
-                inputJSONBuffers.set(blockIndex, currentBuffer + event.delta.partial_json);
-              }
-              break;
-            case "message_delta":
-              if (event.delta.stop_reason) stopReason = event.delta.stop_reason;
-              if (event.delta.stop_sequence) stopSequence = event.delta.stop_sequence;
-              if (event.usage) usage = { ...usage, ...event.usage };
-              break;
-            case "content_block_stop":
-              const stopIndex = event.index;
-              const block = contentBlocks[stopIndex];
-              if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
-                const jsonStr = inputJSONBuffers.get(stopIndex);
-                if (jsonStr) {
-                  try {
-                    block.input = JSON.parse(jsonStr);
-                  } catch (error) {
-                    debugLogger.error("JSON_PARSE_ERROR", {
-                      blockIndex: stopIndex,
-                      jsonStr,
-                      error: error instanceof Error ? error.message : String(error)
-                    });
-                    block.input = {};
-                  }
-                  inputJSONBuffers.delete(stopIndex);
-                }
-              }
-              break;
-            case "message_stop":
-              inputJSONBuffers.clear();
-              break;
-          }
-          if (event.type === "message_stop") {
-            break;
-          }
-        }
-        if (!finalResponse || !messageStartEvent) {
-          throw new Error("Stream ended without proper message structure");
+        if (maxThinkingTokens > 0) {
+          ;
+          params.extra_headers = {
+            "anthropic-beta": "max-tokens-3-5-sonnet-2024-07-15"
+          };
+          params.thinking = { max_tokens: maxThinkingTokens };
         }
-        finalResponse = {
-          ...messageStartEvent.message,
-          content: contentBlocks.filter(Boolean),
-          stop_reason: stopReason,
-          stop_sequence: stopSequence,
-          usage: {
-            ...messageStartEvent.message.usage,
-            ...usage
-          }
-        };
-        return finalResponse;
-      } else {
-        debugLogger.api("ANTHROPIC_API_CALL_START_NON_STREAMING", {
+        debugLogger.api("ANTHROPIC_API_CALL_START_STREAMING", {
           endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
           model,
           provider,
@@ -1156,20 +999,151 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
           apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
           maxTokens: params.max_tokens,
           temperature: MAIN_QUERY_TEMPERATURE,
+          params,
           messageCount: params.messages?.length || 0,
-          streamMode: false,
+          streamMode: true,
           toolsCount: toolSchemas.length,
           thinkingTokens: maxThinkingTokens,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           modelProfileId: modelProfile?.modelName,
           modelProfileName: modelProfile?.name
         });
-        return await anthropic.beta.messages.create(params, {
-          signal
-          // ← CRITICAL: Connect the AbortSignal to API call
-        });
-      }
-    }, { signal });
+        if (config.stream) {
+          const stream = await anthropic.beta.messages.create(
+            {
+              ...params,
+              stream: true
+            },
+            {
+              signal
+              // ← CRITICAL: Connect the AbortSignal to API call
+            }
+          );
+          let finalResponse = null;
+          let messageStartEvent = null;
+          const contentBlocks = [];
+          const inputJSONBuffers = /* @__PURE__ */ new Map();
+          let usage = null;
+          let stopReason = null;
+          let stopSequence = null;
+          for await (const event of stream) {
+            if (signal.aborted) {
+              debugLogger.flow("STREAM_ABORTED", {
+                eventType: event.type,
+                timestamp: Date.now()
+              });
+              throw new Error("Request was cancelled");
+            }
+            switch (event.type) {
+              case "message_start":
+                messageStartEvent = event;
+                finalResponse = {
+                  ...event.message,
+                  content: []
+                  // Will be populated from content blocks
+                };
+                break;
+              case "content_block_start":
+                contentBlocks[event.index] = { ...event.content_block };
+                if (event.content_block.type === "tool_use") {
+                  inputJSONBuffers.set(event.index, "");
+                }
+                break;
+              case "content_block_delta":
+                const blockIndex = event.index;
+                if (!contentBlocks[blockIndex]) {
+                  contentBlocks[blockIndex] = {
+                    type: event.delta.type === "text_delta" ? "text" : "tool_use",
+                    text: event.delta.type === "text_delta" ? "" : void 0
+                  };
+                  if (event.delta.type === "input_json_delta") {
+                    inputJSONBuffers.set(blockIndex, "");
+                  }
+                }
+                if (event.delta.type === "text_delta") {
+                  contentBlocks[blockIndex].text += event.delta.text;
+                } else if (event.delta.type === "input_json_delta") {
+                  const currentBuffer = inputJSONBuffers.get(blockIndex) || "";
+                  inputJSONBuffers.set(
+                    blockIndex,
+                    currentBuffer + event.delta.partial_json
+                  );
+                }
+                break;
+              case "message_delta":
+                if (event.delta.stop_reason)
+                  stopReason = event.delta.stop_reason;
+                if (event.delta.stop_sequence)
+                  stopSequence = event.delta.stop_sequence;
+                if (event.usage) usage = { ...usage, ...event.usage };
+                break;
+              case "content_block_stop":
+                const stopIndex = event.index;
+                const block = contentBlocks[stopIndex];
+                if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
+                  const jsonStr = inputJSONBuffers.get(stopIndex);
+                  if (jsonStr) {
+                    try {
+                      block.input = JSON.parse(jsonStr);
+                    } catch (error) {
+                      debugLogger.error("JSON_PARSE_ERROR", {
+                        blockIndex: stopIndex,
+                        jsonStr,
+                        error: error instanceof Error ? error.message : String(error)
+                      });
+                      block.input = {};
+                    }
+                    inputJSONBuffers.delete(stopIndex);
+                  }
+                }
+                break;
+              case "message_stop":
+                inputJSONBuffers.clear();
+                break;
+            }
+            if (event.type === "message_stop") {
+              break;
+            }
+          }
+          if (!finalResponse || !messageStartEvent) {
+            throw new Error("Stream ended without proper message structure");
+          }
+          finalResponse = {
+            ...messageStartEvent.message,
+            content: contentBlocks.filter(Boolean),
+            stop_reason: stopReason,
+            stop_sequence: stopSequence,
+            usage: {
+              ...messageStartEvent.message.usage,
+              ...usage
+            }
+          };
+          return finalResponse;
+        } else {
+          debugLogger.api("ANTHROPIC_API_CALL_START_NON_STREAMING", {
+            endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
+            model,
+            provider,
+            apiKeyConfigured: !!modelProfile?.apiKey,
+            apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
+            maxTokens: params.max_tokens,
+            temperature: MAIN_QUERY_TEMPERATURE,
+            messageCount: params.messages?.length || 0,
+            streamMode: false,
+            toolsCount: toolSchemas.length,
+            thinkingTokens: maxThinkingTokens,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            modelProfileId: modelProfile?.modelName,
+            modelProfileName: modelProfile?.name
+          });
+          return await anthropic.beta.messages.create(params, {
+            signal
+            // ← CRITICAL: Connect the AbortSignal to API call
+          });
+        }
+      },
+      { signal }
+    );
     debugLogger.api("ANTHROPIC_API_CALL_SUCCESS", {
       content: response.content
     });
@@ -1334,86 +1308,121 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
   let attemptNumber = 0;
   let response;
   try {
-    response = await withRetry(async (attempt) => {
-      attemptNumber = attempt;
-      start = Date.now();
-      const maxTokens = getMaxTokensFromProfile(modelProfile);
-      const isGPT5 = isGPT5Model(model);
-      const opts = {
-        model,
-        ...isGPT5 ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
-        messages: [...openaiSystem, ...openaiMessages],
-        temperature: isGPT5 ? 1 : MAIN_QUERY_TEMPERATURE
-      };
-      if (config.stream) {
-        ;
-        opts.stream = true;
-        opts.stream_options = {
-          include_usage: true
+    response = await withRetry(
+      async (attempt) => {
+        attemptNumber = attempt;
+        start = Date.now();
+        const maxTokens = getMaxTokensFromProfile(modelProfile);
+        const isGPT5 = isGPT5Model(model);
+        const opts = {
+          model,
+          ...isGPT5 ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
+          messages: [...openaiSystem, ...openaiMessages],
+          temperature: isGPT5 ? 1 : MAIN_QUERY_TEMPERATURE
         };
-      }
-      if (toolSchemas.length > 0) {
-        opts.tools = toolSchemas;
-        opts.tool_choice = "auto";
-      }
-      const reasoningEffort = await getReasoningEffort(modelProfile, messages);
-      if (reasoningEffort) {
-        opts.reasoning_effort = reasoningEffort;
-      }
-      if (modelProfile && modelProfile.modelName) {
-        debugLogger.api("USING_MODEL_PROFILE_PATH", {
-          modelProfileName: modelProfile.modelName,
-          modelName: modelProfile.modelName,
-          provider: modelProfile.provider,
-          baseURL: modelProfile.baseURL,
-          apiKeyExists: !!modelProfile.apiKey,
-          requestId: getCurrentRequest()?.id
-        });
-        const USE_NEW_ADAPTER_SYSTEM = process.env.USE_NEW_ADAPTERS !== "false";
-        if (USE_NEW_ADAPTER_SYSTEM) {
-          const adapter = ModelAdapterFactory.createAdapter(modelProfile);
-          const unifiedParams = {
-            messages: openaiMessages,
-            systemPrompt: openaiSystem.map((s) => s.content),
-            tools,
-            maxTokens: getMaxTokensFromProfile(modelProfile),
-            stream: config.stream,
-            reasoningEffort,
-            temperature: isGPT5Model(model) ? 1 : MAIN_QUERY_TEMPERATURE,
-            previousResponseId: toolUseContext?.responseState?.previousResponseId,
-            verbosity: "high"
-            // High verbosity for coding tasks
+        if (config.stream) {
+          ;
+          opts.stream = true;
+          opts.stream_options = {
+            include_usage: true
           };
-          const request = adapter.createRequest(unifiedParams);
-          if (ModelAdapterFactory.shouldUseResponsesAPI(modelProfile)) {
-            const { callGPT5ResponsesAPI } = await import("./openai.js");
-            const response2 = await callGPT5ResponsesAPI(modelProfile, request, signal);
-            const unifiedResponse = adapter.parseResponse(response2);
-            const apiMessage = {
-              role: "assistant",
-              content: unifiedResponse.content,
-              tool_calls: unifiedResponse.toolCalls,
-              usage: {
-                prompt_tokens: unifiedResponse.usage.promptTokens,
-                completion_tokens: unifiedResponse.usage.completionTokens
-              }
-            };
-            const assistantMsg = {
-              type: "assistant",
-              message: apiMessage,
-              costUSD: 0,
-              // Will be calculated later
-              durationMs: Date.now() - start,
-              uuid: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-              responseId: unifiedResponse.responseId
-              // For state management
+        }
+        if (toolSchemas.length > 0) {
+          opts.tools = toolSchemas;
+          opts.tool_choice = "auto";
+        }
+        const reasoningEffort = await getReasoningEffort(modelProfile, messages);
+        if (reasoningEffort) {
+          opts.reasoning_effort = reasoningEffort;
+        }
+        if (modelProfile && modelProfile.modelName) {
+          debugLogger.api("USING_MODEL_PROFILE_PATH", {
+            modelProfileName: modelProfile.modelName,
+            modelName: modelProfile.modelName,
+            provider: modelProfile.provider,
+            baseURL: modelProfile.baseURL,
+            apiKeyExists: !!modelProfile.apiKey,
+            requestId: getCurrentRequest()?.id
+          });
+          const USE_NEW_ADAPTER_SYSTEM = process.env.USE_NEW_ADAPTERS !== "false";
+          if (USE_NEW_ADAPTER_SYSTEM) {
+            const adapter = ModelAdapterFactory.createAdapter(modelProfile);
+            const unifiedParams = {
+              messages: openaiMessages,
+              systemPrompt: openaiSystem.map((s) => s.content),
+              tools,
+              maxTokens: getMaxTokensFromProfile(modelProfile),
+              stream: config.stream,
+              reasoningEffort,
+              temperature: isGPT5Model(model) ? 1 : MAIN_QUERY_TEMPERATURE,
+              previousResponseId: toolUseContext?.responseState?.previousResponseId,
+              verbosity: "high"
+              // High verbosity for coding tasks
             };
-            return assistantMsg;
+            const request = adapter.createRequest(unifiedParams);
+            if (ModelAdapterFactory.shouldUseResponsesAPI(modelProfile)) {
+              const { callGPT5ResponsesAPI } = await import("./openai.js");
+              const response2 = await callGPT5ResponsesAPI(
+                modelProfile,
+                request,
+                signal
+              );
+              const unifiedResponse = adapter.parseResponse(response2);
+              const apiMessage = {
+                role: "assistant",
+                content: unifiedResponse.content,
+                tool_calls: unifiedResponse.toolCalls,
+                usage: {
+                  prompt_tokens: unifiedResponse.usage.promptTokens,
+                  completion_tokens: unifiedResponse.usage.completionTokens
+                }
+              };
+              const assistantMsg = {
+                type: "assistant",
+                message: apiMessage,
+                costUSD: 0,
+                // Will be calculated later
+                durationMs: Date.now() - start,
+                uuid: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                responseId: unifiedResponse.responseId
+                // For state management
+              };
+              return assistantMsg;
+            } else {
+              const s = await getCompletionWithProfile(
+                modelProfile,
+                request,
+                0,
+                10,
+                signal
+              );
+              let finalResponse;
+              if (config.stream) {
+                finalResponse = await handleMessageStream(
+                  s,
+                  signal
+                );
+              } else {
+                finalResponse = s;
+              }
+              const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
+              return r;
+            }
           } else {
-            const s = await getCompletionWithProfile(modelProfile, request, 0, 10, signal);
+            const completionFunction = isGPT5Model(modelProfile.modelName) ? getGPT5CompletionWithProfile : getCompletionWithProfile;
+            const s = await completionFunction(
+              modelProfile,
+              opts,
+              0,
+              10,
+              signal
+            );
             let finalResponse;
-            if (config.stream) {
-              finalResponse = await handleMessageStream(s, signal);
+            if (opts.stream) {
+              finalResponse = await handleMessageStream(
+                s,
+                signal
+              );
             } else {
               finalResponse = s;
             }
@@ -1421,39 +1430,29 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
             return r;
           }
         } else {
-          const completionFunction = isGPT5Model(modelProfile.modelName) ? getGPT5CompletionWithProfile : getCompletionWithProfile;
-          const s = await completionFunction(modelProfile, opts, 0, 10, signal);
-          let finalResponse;
-          if (opts.stream) {
-            finalResponse = await handleMessageStream(s, signal);
-          } else {
-            finalResponse = s;
-          }
-          const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
-          return r;
+          debugLogger.api("USING_LEGACY_PATH", {
+            modelProfileExists: !!modelProfile,
+            modelProfileId: modelProfile?.modelName,
+            modelNameExists: !!modelProfile?.modelName,
+            fallbackModel: "main",
+            actualModel: model,
+            requestId: getCurrentRequest()?.id
+          });
+          const errorDetails = {
+            modelProfileExists: !!modelProfile,
+            modelProfileId: modelProfile?.modelName,
+            modelNameExists: !!modelProfile?.modelName,
+            requestedModel: model,
+            requestId: getCurrentRequest()?.id
+          };
+          debugLogger.error("NO_VALID_MODEL_PROFILE", errorDetails);
+          throw new Error(
+            `No valid ModelProfile available for model: ${model}. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
+          );
         }
-      } else {
-        debugLogger.api("USING_LEGACY_PATH", {
-          modelProfileExists: !!modelProfile,
-          modelProfileId: modelProfile?.modelName,
-          modelNameExists: !!modelProfile?.modelName,
-          fallbackModel: "main",
-          actualModel: model,
-          requestId: getCurrentRequest()?.id
-        });
-        const errorDetails = {
-          modelProfileExists: !!modelProfile,
-          modelProfileId: modelProfile?.modelName,
-          modelNameExists: !!modelProfile?.modelName,
-          requestedModel: model,
-          requestId: getCurrentRequest()?.id
-        };
-        debugLogger.error("NO_VALID_MODEL_PROFILE", errorDetails);
-        throw new Error(
-          `No valid ModelProfile available for model: ${model}. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
-        );
-      }
-    }, { signal });
+      },
+      { signal }
+    );
   } catch (error) {
     logError(error);
     return getAssistantMessageFromError(error);