@within-7/minto 0.4.1 → 0.4.3

package/dist/query.js

@@ -1,753 +0,0 @@
-import {
-  messagePairValidForBinaryFeedback,
-  shouldUseBinaryFeedback
-} from "./components/binary-feedback/utils.js";
-import {
-  formatSystemPromptWithContext,
-  queryLLM
-} from "./services/claude.js";
-import { emitReminderEvent } from "./services/systemReminder.js";
-import {
-  TOOL_INPUT_EXAMPLES,
-  TOOL_DESCRIPTIONS,
-  PARAMETER_DESCRIPTIONS
-} from "./constants/toolInputExamples.js";
-import { all } from "./utils/generators.js";
-import { logError } from "./utils/log.js";
-import {
-  debug,
-  markPhase,
-  getCurrentRequest,
-  logUserFriendly
-} from "./utils/debugLogger.js";
-import {
-  createAssistantMessage,
-  createAssistantAPIErrorMessage,
-  createProgressMessage,
-  createToolResultStopMessage,
-  createUserMessage,
-  INTERRUPT_MESSAGE,
-  INTERRUPT_MESSAGE_FOR_TOOL_USE,
-  normalizeMessagesForAPI
-} from "./utils/messages.js";
-import { withTimeout, ToolTimeoutError } from "./utils/toolTimeout.js";
-import { setStreamingState, resetStreamingState } from "./utils/streamingState.js";
-import { BashTool } from "./tools/BashTool/BashTool.js";
-function normalizeToolResultContent(content) {
-  if (content === null || content === void 0) {
-    return "(no content)";
-  }
-  if (typeof content === "string") {
-    return content || "(no content)";
-  }
-  if (Array.isArray(content)) {
-    return content.map((item) => {
-      if (typeof item === "string") return item;
-      if (item && typeof item === "object" && "text" in item)
-        return String(item.text);
-      return JSON.stringify(item);
-    }).join("\n");
-  }
-  if (typeof content === "object") {
-    if ("text" in content) return String(content.text);
-    return JSON.stringify(content);
-  }
-  return String(content);
-}
-import { getCwd } from "./utils/state.js";
-import { checkAutoCompact } from "./utils/autoCompactCore.js";
-import { getHookManager } from "./utils/hookManager.js";
-import { recordToolCall } from "./utils/stats.js";
-const MAX_TOOL_USE_CONCURRENCY = 10;
-const MAX_QUERY_DEPTH = 50;
-class QueryDepthExceededError extends Error {
-  constructor(depth) {
-    super(
-      `Query depth limit exceeded (${depth}/${MAX_QUERY_DEPTH}). This usually indicates an infinite loop in tool usage.`
-    );
-    this.name = "QueryDepthExceededError";
-  }
-}
-async function queryWithBinaryFeedback(toolUseContext, getAssistantResponse, getBinaryFeedbackResponse) {
-  if (process.env.USER_TYPE !== "ant" || !getBinaryFeedbackResponse || !await shouldUseBinaryFeedback()) {
-    const assistantMessage = await getAssistantResponse();
-    if (toolUseContext.abortController.signal.aborted) {
-      return { message: null, shouldSkipPermissionCheck: false };
-    }
-    return { message: assistantMessage, shouldSkipPermissionCheck: false };
-  }
-  const [m1, m2] = await Promise.all([
-    getAssistantResponse(),
-    getAssistantResponse()
-  ]);
-  if (toolUseContext.abortController.signal.aborted) {
-    return { message: null, shouldSkipPermissionCheck: false };
-  }
-  if (m2.isApiErrorMessage) {
-    return { message: m1, shouldSkipPermissionCheck: false };
-  }
-  if (m1.isApiErrorMessage) {
-    return { message: m2, shouldSkipPermissionCheck: false };
-  }
-  if (!messagePairValidForBinaryFeedback(m1, m2)) {
-    return { message: m1, shouldSkipPermissionCheck: false };
-  }
-  return await getBinaryFeedbackResponse(m1, m2);
-}
-async function* query(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse, _depth = 0) {
-  if (_depth > MAX_QUERY_DEPTH) {
-    const error = new QueryDepthExceededError(_depth);
-    logError(error);
-    yield createAssistantAPIErrorMessage(error.message);
-    return;
-  }
-  const currentRequest = getCurrentRequest();
-  markPhase("QUERY_INIT");
-  setStreamingState({ phase: "compacting" });
-  const { messages: processedMessages, wasCompacted } = await checkAutoCompact(
-    messages,
-    toolUseContext
-  );
-  if (wasCompacted) {
-    messages = processedMessages;
-    debug.flow("CONTEXT_COMPACTED", {
-      originalCount: messages.length,
-      compactedCount: processedMessages.length
-    });
-  }
-  markPhase("SYSTEM_PROMPT_BUILD");
-  const { systemPrompt: fullSystemPrompt, reminders } = formatSystemPromptWithContext(systemPrompt, context, toolUseContext.agentId);
-  emitReminderEvent("session:startup", {
-    agentId: toolUseContext.agentId,
-    messages: messages.length,
-    timestamp: Date.now()
-  });
-  if (reminders) {
-    fullSystemPrompt.push(reminders);
-  }
-  markPhase("LLM_PREPARATION");
-  setStreamingState({ phase: "waiting" });
-  function getAssistantResponse() {
-    return queryLLM(
-      normalizeMessagesForAPI(messages),
-      fullSystemPrompt,
-      toolUseContext.options.maxThinkingTokens,
-      toolUseContext.options.tools,
-      toolUseContext.abortController.signal,
-      {
-        safeMode: toolUseContext.options.safeMode ?? false,
-        model: toolUseContext.options.model || "main",
-        prependCLISysprompt: true,
-        toolUseContext
-      }
-    );
-  }
-  const result = await queryWithBinaryFeedback(
-    toolUseContext,
-    getAssistantResponse,
-    getBinaryFeedbackResponse
-  );
-  if (toolUseContext.abortController.signal.aborted) {
-    yield createAssistantMessage(INTERRUPT_MESSAGE);
-    return;
-  }
-  if (result.message === null) {
-    yield createAssistantMessage(INTERRUPT_MESSAGE);
-    return;
-  }
-  const assistantMessage = result.message;
-  const shouldSkipPermissionCheck = result.shouldSkipPermissionCheck;
-  setStreamingState({ phase: "generating" });
-  yield assistantMessage;
-  const toolUseMessages = assistantMessage.message.content.filter(
-    (_) => _.type === "tool_use"
-  );
-  if (!toolUseMessages.length) {
-    resetStreamingState();
-    const hookManager = getHookManager();
-    if (hookManager) {
-      hookManager.executeStop().catch(() => {
-      });
-    }
-    return;
-  }
-  const toolResults = [];
-  const serialTools = [];
-  const concurrentTools = [];
-  for (const msg of toolUseMessages) {
-    const tool = toolUseContext.options.tools.find((t) => t.name === msg.name);
-    const isSafe = tool?.isConcurrencySafe?.() ?? tool?.isReadOnly?.() ?? false;
-    if (isSafe) {
-      concurrentTools.push(msg);
-    } else {
-      serialTools.push(msg);
-    }
-  }
-  debug.flow("TOOL_CONCURRENCY_CHECK", {
-    toolCount: toolUseMessages.length,
-    serialTools: serialTools.map((msg) => msg.name),
-    concurrentTools: concurrentTools.map((msg) => msg.name),
-    concurrencyDetails: toolUseMessages.map((msg) => {
-      const tool = toolUseContext.options.tools.find((t) => t.name === msg.name);
-      return {
-        name: msg.name,
-        isConcurrencySafe: tool?.isConcurrencySafe?.() ?? "undefined",
-        isReadOnly: tool?.isReadOnly?.() ?? "undefined"
-      };
-    })
-  });
-  if (serialTools.length > 0) {
-    debug.flow("SERIAL_TOOLS_START", {
-      count: serialTools.length,
-      tools: serialTools.map((t) => t.name)
-    });
-    for await (const message of runToolsSerially(
-      serialTools,
-      assistantMessage,
-      canUseTool,
-      toolUseContext,
-      shouldSkipPermissionCheck
-    )) {
-      yield message;
-      if (message.type === "user") {
-        toolResults.push(message);
-      }
-    }
-    debug.flow("SERIAL_TOOLS_COMPLETE", {
-      count: serialTools.length
-    });
-  }
-  if (concurrentTools.length > 0) {
-    debug.flow("CONCURRENT_TOOLS_START", {
-      count: concurrentTools.length,
-      tools: concurrentTools.map((t) => t.name),
-      maxConcurrency: MAX_TOOL_USE_CONCURRENCY
-    });
-    setStreamingState({
-      phase: "concurrent",
-      concurrentCount: concurrentTools.length
-    });
-    const concurrentStartTime = Date.now();
-    for await (const message of runToolsConcurrently(
-      concurrentTools,
-      assistantMessage,
-      canUseTool,
-      toolUseContext,
-      shouldSkipPermissionCheck
-    )) {
-      yield message;
-      if (message.type === "user") {
-        toolResults.push(message);
-      }
-    }
-    debug.flow("CONCURRENT_TOOLS_COMPLETE", {
-      count: concurrentTools.length,
-      durationMs: Date.now() - concurrentStartTime
-    });
-  }
-  if (toolUseContext.abortController.signal.aborted) {
-    yield createAssistantMessage(INTERRUPT_MESSAGE_FOR_TOOL_USE);
-    return;
-  }
-  const orderedToolResults = toolResults.sort((a, b) => {
-    const aIndex = toolUseMessages.findIndex(
-      (tu) => tu.id === a.message.content[0].id
-    );
-    const bIndex = toolUseMessages.findIndex(
-      (tu) => tu.id === b.message.content[0].id
-    );
-    return aIndex - bIndex;
-  });
-  let modifiedContext = toolUseContext;
-  const additionalMessages = [];
-  for (const result2 of orderedToolResults) {
-    if (result2.toolUseResult?.contextModifier) {
-      modifiedContext = result2.toolUseResult.contextModifier.modifyContext(modifiedContext);
-      debug.flow("CONTEXT_MODIFIER_APPLIED", {
-        toolResultId: result2.message.content[0]?.id
-      });
-    }
-    if (result2.toolUseResult?.newMessages && Array.isArray(result2.toolUseResult.newMessages)) {
-      for (const msg of result2.toolUseResult.newMessages) {
-        if (msg && typeof msg === "object" && "type" in msg) {
-          additionalMessages.push(msg);
-        }
-      }
-      debug.flow("NEW_MESSAGES_ADDED", {
-        count: result2.toolUseResult.newMessages.length
-      });
-    }
-  }
-  try {
-    yield* await query(
-      [
-        ...messages,
-        assistantMessage,
-        ...orderedToolResults,
-        ...additionalMessages
-      ],
-      systemPrompt,
-      context,
-      canUseTool,
-      modifiedContext,
-      // Use modified context if contextModifier was applied
-      getBinaryFeedbackResponse,
-      _depth + 1
-      // Increment depth for recursion tracking
-    );
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logError(`Recursive query error: ${errorMessage}`);
-    yield createAssistantAPIErrorMessage(`Query failed: ${errorMessage}`);
-    throw error;
-  }
-}
-async function* runToolsConcurrently(toolUseMessages, assistantMessage, canUseTool, toolUseContext, shouldSkipPermissionCheck) {
-  yield* all(
-    toolUseMessages.map(
-      (toolUse) => runToolUse(
-        toolUse,
-        new Set(toolUseMessages.map((_) => _.id)),
-        assistantMessage,
-        canUseTool,
-        toolUseContext,
-        shouldSkipPermissionCheck
-      )
-    ),
-    MAX_TOOL_USE_CONCURRENCY,
-    toolUseContext.abortController.signal
-    // Pass abort signal for proper cancellation
-  );
-}
-async function* runToolsSerially(toolUseMessages, assistantMessage, canUseTool, toolUseContext, shouldSkipPermissionCheck) {
-  for (const toolUse of toolUseMessages) {
-    yield* runToolUse(
-      toolUse,
-      new Set(toolUseMessages.map((_) => _.id)),
-      assistantMessage,
-      canUseTool,
-      toolUseContext,
-      shouldSkipPermissionCheck
-    );
-  }
-}
-async function* runToolUse(toolUse, siblingToolUseIDs, assistantMessage, canUseTool, toolUseContext, shouldSkipPermissionCheck) {
-  const currentRequest = getCurrentRequest();
-  debug.flow("TOOL_USE_START", {
-    toolName: toolUse.name,
-    toolUseID: toolUse.id,
-    inputSize: JSON.stringify(toolUse.input).length,
-    siblingToolCount: siblingToolUseIDs.size,
-    shouldSkipPermissionCheck: !!shouldSkipPermissionCheck,
-    requestId: currentRequest?.id
-  });
-  logUserFriendly(
-    "TOOL_EXECUTION",
-    {
-      toolName: toolUse.name,
-      action: "Starting",
-      target: toolUse.input ? Object.keys(toolUse.input).join(", ") : ""
-    },
-    currentRequest?.id
-  );
-  const toolName = toolUse.name;
-  const tool = toolUseContext.options.tools.find((t) => t.name === toolName);
-  setStreamingState({ phase: "tool_use", toolName });
-  if (!tool) {
-    debug.error("TOOL_NOT_FOUND", {
-      requestedTool: toolName,
-      availableTools: toolUseContext.options.tools.map((t) => t.name),
-      toolUseID: toolUse.id,
-      requestId: currentRequest?.id
-    });
-    yield createUserMessage([
-      {
-        type: "tool_result",
-        content: `Error: No such tool available: ${toolName}`,
-        is_error: true,
-        tool_use_id: toolUse.id
-      }
-    ]);
-    return;
-  }
-  const toolInput = toolUse.input;
-  debug.flow("TOOL_VALIDATION_START", {
-    toolName: tool.name,
-    toolUseID: toolUse.id,
-    inputKeys: Object.keys(toolInput),
-    requestId: currentRequest?.id
-  });
-  try {
-    if (toolUseContext.abortController.signal.aborted) {
-      debug.flow("TOOL_USE_CANCELLED_BEFORE_START", {
-        toolName: tool.name,
-        toolUseID: toolUse.id,
-        abortReason: "AbortController signal",
-        requestId: currentRequest?.id
-      });
-      const message = createUserMessage([
-        createToolResultStopMessage(toolUse.id)
-      ]);
-      yield message;
-      return;
-    }
-    let hasProgressMessages = false;
-    for await (const message of checkPermissionsAndCallTool(
-      tool,
-      toolUse.id,
-      siblingToolUseIDs,
-      toolInput,
-      toolUseContext,
-      canUseTool,
-      assistantMessage,
-      shouldSkipPermissionCheck
-    )) {
-      if (toolUseContext.abortController.signal.aborted) {
-        debug.flow("TOOL_USE_CANCELLED_DURING_EXECUTION", {
-          toolName: tool.name,
-          toolUseID: toolUse.id,
-          hasProgressMessages,
-          abortReason: "AbortController signal during execution",
-          requestId: currentRequest?.id
-        });
-        if (hasProgressMessages && message.type === "progress") {
-          yield message;
-        }
-        const cancelMessage = createUserMessage([
-          createToolResultStopMessage(toolUse.id)
-        ]);
-        yield cancelMessage;
-        return;
-      }
-      if (message.type === "progress") {
-        hasProgressMessages = true;
-      }
-      yield message;
-    }
-  } catch (e) {
-    logError(e);
-    const hookManager = getHookManager();
-    if (hookManager) {
-      hookManager.executePostToolUseFailure(
-        toolName,
-        toolInput,
-        e instanceof Error ? e.message : String(e)
-      ).catch(() => {
-      });
-    }
-    const errorMessage = createUserMessage([
-      {
-        type: "tool_result",
-        content: `Tool execution failed: ${e instanceof Error ? e.message : String(e)}`,
-        is_error: true,
-        tool_use_id: toolUse.id
-      }
-    ]);
-    yield errorMessage;
-  }
-}
-function normalizeToolInput(tool, input) {
-  switch (tool) {
-    case BashTool: {
-      const { command, timeout } = BashTool.inputSchema.parse(input);
-      return {
-        command: command.replace(`cd ${getCwd()} && `, ""),
-        ...timeout ? { timeout } : {}
-      };
-    }
-    default:
-      return input;
-  }
-}
-function buildToolInputErrorMessage(tool, input, validationError) {
-  const parseError = input;
-  if (parseError.__parse_error__) {
-    let message2 = [
-      `Error: Failed to parse tool parameters for "${tool.name}".`,
-      ``,
-      `The model generated invalid JSON. This is typically a temporary issue.`,
-      ``,
-      `Expected format: ${TOOL_INPUT_EXAMPLES[tool.name] || "{...}"}`
-    ];
-    if (parseError.__error_message__) {
-      message2.push(`Parse error: ${parseError.__error_message__}`);
-    }
-    if (parseError.__raw_json_preview__) {
-      message2.push(``, `Raw JSON preview:`, parseError.__raw_json_preview__);
-    }
-    message2.push(
-      ``,
-      `Suggestions:`,
-      `\u2022 Retry your request - the model may succeed on the next attempt`,
-      `\u2022 Try simplifying your request with fewer parameters`,
-      `\u2022 Check if special characters in values need escaping`
-    );
-    return message2.join("\n");
-  }
-  const inputKeys = Object.keys(input);
-  const isEmptyInput = inputKeys.length === 0;
-  const example = TOOL_INPUT_EXAMPLES[tool.name] || "{...required parameters...}";
-  const description = TOOL_DESCRIPTIONS[tool.name];
-  const paramDescriptions = PARAMETER_DESCRIPTIONS[tool.name];
-  let message = [
-    `Error: Invalid parameters for "${tool.name}" tool.`,
-    ``,
-    `Expected format:`,
-    `${example}`
-  ];
-  if (description) {
-    message.push(``, `Description: ${description}`);
-  }
-  if (isEmptyInput) {
-    message.push(
-      ``,
-      `Issue: The tool was called without any parameters.`,
-      `This usually indicates a JSON parsing error in the model's response.`
-    );
-  } else {
-    message.push(
-      ``,
-      `Issue: ${validationError.message}`,
-      `Provided parameters: ${inputKeys.length > 0 ? inputKeys.join(", ") : "(none)"}`
-    );
-    if (paramDescriptions) {
-      message.push(``, `Parameter guide:`);
-      for (const [param, desc] of Object.entries(paramDescriptions)) {
-        message.push(`\u2022 ${param}: ${desc}`);
-      }
-    }
-  }
-  message.push(
-    ``,
-    `Suggestions:`,
-    `\u2022 Ensure all required parameters are provided`,
-    `\u2022 Check that parameters have the correct type (string, number, boolean)`,
-    `\u2022 Verify file paths are absolute (start with /)`,
-    `\u2022 Retry your request - the model often succeeds on retry`
-  );
-  return message.join("\n");
-}
-async function* checkPermissionsAndCallTool(tool, toolUseID, siblingToolUseIDs, input, context, canUseTool, assistantMessage, shouldSkipPermissionCheck) {
-  const isValidInput = tool.inputSchema.safeParse(input);
-  if (!isValidInput.success) {
-    let errorMessage = buildToolInputErrorMessage(
-      tool,
-      input,
-      isValidInput.error
-    );
-    yield createUserMessage([
-      {
-        type: "tool_result",
-        content: errorMessage,
-        is_error: true,
-        tool_use_id: toolUseID
-      }
-    ]);
-    return;
-  }
-  const normalizedInput = normalizeToolInput(tool, input);
-  const isValidCall = await tool.validateInput?.(
-    normalizedInput,
-    context
-  );
-  if (isValidCall?.result === false) {
-    yield createUserMessage([
-      {
-        type: "tool_result",
-        content: isValidCall.message,
-        is_error: true,
-        tool_use_id: toolUseID
-      }
-    ]);
-    return;
-  }
-  const permissionResult = shouldSkipPermissionCheck ? { result: true } : await canUseTool(tool, normalizedInput, context, assistantMessage);
-  if (permissionResult.result === false) {
-    yield createUserMessage([
-      {
-        type: "tool_result",
-        content: permissionResult.message,
-        is_error: true,
-        tool_use_id: toolUseID
-      }
-    ]);
-    return;
-  }
-  if (!shouldSkipPermissionCheck && !permissionResult.result) {
-    setStreamingState({ phase: "permission" });
-  }
-  const hookManager = getHookManager();
-  if (hookManager) {
-    try {
-      const decision = await hookManager.executePreToolUse(
-        tool.name,
-        normalizedInput
-      );
-      if (!decision.shouldContinue) {
-        if (decision.shouldAskUser) {
-          const approved = await canUseTool(
-            tool,
-            normalizedInput,
-            context,
-            assistantMessage
-          );
-          if (approved.result === false) {
-            yield createUserMessage([
-              {
-                type: "tool_result",
-                content: decision.reason || "Hook requested approval but user denied",
-                is_error: true,
-                tool_use_id: toolUseID
-              }
-            ]);
-            return;
-          }
-        } else {
-          yield createUserMessage([
-            {
-              type: "tool_result",
-              content: decision.reason || "Tool execution blocked by hook",
-              is_error: true,
-              tool_use_id: toolUseID
-            }
-          ]);
-          return;
-        }
-      }
-    } catch (error) {
-      debug.error("PreToolUse hook failed", { error });
-    }
-  }
-  let toolOutput = null;
-  try {
-    const contextWithToolUseId = {
-      ...context,
-      toolUseId: toolUseID
-    };
-    const rawGenerator = tool.call(
-      normalizedInput,
-      contextWithToolUseId
-    );
-    const generator = withTimeout(rawGenerator, tool.name);
-    for await (const result of generator) {
-      switch (result.type) {
-        case "result":
-          const normalizedContent = normalizeToolResultContent(
-            result.resultForAssistant ?? result.data
-          );
-          toolOutput = {
-            data: result.data,
-            resultForAssistant: normalizedContent,
-            // Preserve contextModifier and newMessages for caller to process
-            newMessages: result.newMessages,
-            contextModifier: result.contextModifier
-          };
-          yield createUserMessage(
-            [
-              {
-                type: "tool_result",
-                content: normalizedContent,
-                tool_use_id: toolUseID
-              }
-            ],
-            toolOutput
-          );
-          try {
-            recordToolCall(tool.name, false);
-          } catch {
-          }
-          if (hookManager && toolOutput) {
-            hookManager.executePostToolUse(
-              tool.name,
-              normalizedInput,
-              toolOutput
-            ).catch((err) => {
-              debug.error("PostToolUse hook failed", { error: err });
-            });
-          }
-          return;
-        case "progress":
-          yield createProgressMessage(
-            toolUseID,
-            siblingToolUseIDs,
-            result.content,
-            result.normalizedMessages || [],
-            result.tools || []
-          );
-          break;
-      }
-    }
-  } catch (error) {
-    try {
-      recordToolCall(tool.name, true);
-    } catch {
-    }
-    const hookMgr = getHookManager();
-    if (hookMgr) {
-      hookMgr.executePostToolUseFailure(
-        tool.name,
-        normalizedInput,
-        error instanceof Error ? error.message : String(error),
-        error instanceof ToolTimeoutError ? "timeout" : void 0
-      ).catch(() => {
-      });
-    }
-    if (error instanceof ToolTimeoutError) {
-      debug.error("TOOL_TIMEOUT", {
-        toolName: tool.name,
-        toolUseID,
-        timeoutMs: error.timeoutMs
-      });
-      yield createUserMessage([
-        {
-          type: "tool_result",
-          content: `Error: ${error.message}. The tool execution was cancelled. Consider breaking this operation into smaller steps or checking if there's an infinite loop.`,
-          is_error: true,
-          tool_use_id: toolUseID
-        }
-      ]);
-      return;
-    }
-    const content = formatError(error);
-    logError(error);
-    yield createUserMessage([
-      {
-        type: "tool_result",
-        content,
-        is_error: true,
-        tool_use_id: toolUseID
-      }
-    ]);
-  }
-}
-function formatError(error) {
-  if (!(error instanceof Error)) {
-    return String(error);
-  }
-  const parts = [error.message];
-  if ("stderr" in error && typeof error.stderr === "string") {
-    parts.push(error.stderr);
-  }
-  if ("stdout" in error && typeof error.stdout === "string") {
-    parts.push(error.stdout);
-  }
-  const fullMessage = parts.filter(Boolean).join("\n");
-  if (fullMessage.length <= 1e4) {
-    return fullMessage;
-  }
-  const halfLength = 5e3;
-  const start = fullMessage.slice(0, halfLength);
-  const end = fullMessage.slice(-halfLength);
-  return `${start}
-
-... [${fullMessage.length - 1e4} characters truncated] ...
-
-${end}`;
-}
-export {
-  QueryDepthExceededError,
-  normalizeToolInput,
-  query,
-  runToolUse
-};
-//# sourceMappingURL=query.js.map