@within-7/minto 0.4.1 → 0.4.3

package/dist/utils/messages.js

@@ -1,667 +0,0 @@
-import { createHash, randomUUID } from "crypto";
-import { getCommand, hasCommand } from "../commands.js";
-import { MalformedCommandError } from "./errors.js";
-import { logError } from "./log.js";
-import { resolve } from "path";
-import { last } from "lodash-es";
-import { memoizeWithLimit } from "./async.js";
-import { NO_CONTENT_MESSAGE } from "../services/claude.js";
-import { setCwd } from "./state.js";
-import { getCwd } from "./state.js";
-import chalk from "chalk";
-import * as React from "react";
-import { StreamingBashOutput } from "../components/StreamingBashOutput.js";
-import { BashTool } from "../tools/BashTool/BashTool.js";
-const INTERRUPT_MESSAGE = "[Request interrupted by user]";
-const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
-const CANCEL_MESSAGE = "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
-const REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
-const NO_RESPONSE_REQUESTED = "No response requested.";
-const SYNTHETIC_ASSISTANT_MESSAGES = /* @__PURE__ */ new Set([
-  INTERRUPT_MESSAGE,
-  INTERRUPT_MESSAGE_FOR_TOOL_USE,
-  CANCEL_MESSAGE,
-  REJECT_MESSAGE,
-  NO_RESPONSE_REQUESTED
-]);
-function baseCreateAssistantMessage(content, extra) {
-  return {
-    type: "assistant",
-    costUSD: 0,
-    durationMs: 0,
-    uuid: randomUUID(),
-    message: {
-      id: randomUUID(),
-      model: "<synthetic>",
-      role: "assistant",
-      stop_reason: "stop_sequence",
-      stop_sequence: "",
-      type: "message",
-      usage: {
-        input_tokens: 0,
-        output_tokens: 0,
-        cache_creation_input_tokens: 0,
-        cache_read_input_tokens: 0
-      },
-      content
-    },
-    ...extra
-  };
-}
-function createAssistantMessage(content) {
-  return baseCreateAssistantMessage([
-    {
-      type: "text",
-      text: content === "" ? NO_CONTENT_MESSAGE : content,
-      citations: []
-    }
-  ]);
-}
-function createAssistantAPIErrorMessage(content) {
-  return baseCreateAssistantMessage(
-    [
-      {
-        type: "text",
-        text: content === "" ? NO_CONTENT_MESSAGE : content,
-        citations: []
-      }
-    ],
-    { isApiErrorMessage: true }
-  );
-}
-function createUserMessage(content, toolUseResult) {
-  const m = {
-    type: "user",
-    message: {
-      role: "user",
-      content
-    },
-    uuid: randomUUID(),
-    toolUseResult
-  };
-  return m;
-}
-function createProgressMessage(toolUseID, siblingToolUseIDs, content, normalizedMessages, tools) {
-  return {
-    type: "progress",
-    content,
-    normalizedMessages,
-    siblingToolUseIDs,
-    tools,
-    toolUseID,
-    uuid: randomUUID()
-  };
-}
-function createToolResultStopMessage(toolUseID) {
-  return {
-    type: "tool_result",
-    content: CANCEL_MESSAGE,
-    is_error: true,
-    tool_use_id: toolUseID
-  };
-}
-async function processUserInput(input, mode, setToolJSX, context, pastedImage) {
-  if (mode === "bash") {
-    const userMessage2 = createUserMessage(`<bash-input>${input}</bash-input>`);
-    if (input.startsWith("cd ")) {
-      const oldCwd = getCwd();
-      const newCwd = resolve(oldCwd, input.slice(3));
-      try {
-        await setCwd(newCwd);
-        return [
-          userMessage2,
-          createAssistantMessage(
-            `<bash-stdout>Changed directory to ${chalk.bold(`${newCwd}/`)}</bash-stdout>`
-          )
-        ];
-      } catch (e) {
-        logError(e);
-        return [
-          userMessage2,
-          createAssistantMessage(
-            `<bash-stderr>cwd error: ${e instanceof Error ? e.message : String(e)}</bash-stderr>`
-          )
-        ];
-      }
-    }
-    const validationResult = await BashTool.validateInput({
-      command: input
-    });
-    if (!validationResult.result) {
-      return [userMessage2, createAssistantMessage(validationResult.message)];
-    }
-    const { BackgroundShellManager } = await import("./BackgroundShellManager.js");
-    const shellId = BackgroundShellManager.getInstance().create(
-      input,
-      context.readFileTimestamps ? getCwd() : process.cwd()
-    );
-    let movedToBackground = false;
-    let completed = false;
-    let completionData = null;
-    setToolJSX({
-      jsx: /* @__PURE__ */ React.createElement(
-        StreamingBashOutput,
-        {
-          shellId,
-          command: input,
-          onMoveToBackground: () => {
-            movedToBackground = true;
-            setToolJSX(null);
-          },
-          onComplete: (stdout, stderr, exitCode) => {
-            completed = true;
-            completionData = { stdout, stderr, exitCode };
-            setToolJSX(null);
-          }
-        }
-      ),
-      shouldHidePromptInput: false
-    });
-    await new Promise((resolve2) => {
-      const checkInterval = setInterval(() => {
-        if (movedToBackground || completed) {
-          clearInterval(checkInterval);
-          resolve2();
-        }
-      }, 100);
-    });
-    if (movedToBackground) {
-      return [
-        userMessage2,
-        createAssistantMessage(
-          `<bash-stdout>Command moved to background (shell ID: ${shellId})
-Use Shift+B to view background tasks</bash-stdout>`
-        )
-      ];
-    } else if (completed && completionData) {
-      return [
-        userMessage2,
-        createAssistantMessage(
-          `<bash-stdout>${completionData.stdout}</bash-stdout><bash-stderr>${completionData.stderr}</bash-stderr>`
-        )
-      ];
-    } else {
-      return [
-        userMessage2,
-        createAssistantMessage(
-          `<bash-stderr>Unexpected error in bash execution</bash-stderr>`
-        )
-      ];
-    }
-  } else if (mode === "koding") {
-    const userMessage2 = createUserMessage(
-      `<koding-input>${input}</koding-input>`
-    );
-    userMessage2.options = {
-      ...userMessage2.options,
-      isKodingRequest: true
-    };
-    return [userMessage2];
-  }
-  if (input.startsWith("/")) {
-    const words = input.slice(1).split(" ");
-    let commandName = words[0];
-    if (words.length > 1 && words[1] === "(MCP)") {
-      commandName = commandName + " (MCP)";
-    }
-    if (!commandName) {
-      return [
-        createAssistantMessage("Commands are in the form `/command [args]`")
-      ];
-    }
-    if (!hasCommand(commandName, context.options.commands)) {
-      return [createUserMessage(input)];
-    }
-    const args = input.slice(commandName.length + 2);
-    const newMessages = await getMessagesForSlashCommand(
-      commandName,
-      args,
-      setToolJSX,
-      context
-    );
-    if (newMessages.length === 0) {
-      return [];
-    }
-    if (newMessages.length === 2 && newMessages[0].type === "user" && newMessages[1].type === "assistant" && typeof newMessages[1].message.content === "string" && newMessages[1].message.content.startsWith("Unknown command:")) {
-      return newMessages;
-    }
-    if (newMessages.length === 2) {
-      return newMessages;
-    }
-    return newMessages;
-  }
-  const isKodingRequest = context.options?.isKodingRequest === true;
-  const kodingContextInfo = context.options?.kodingContext;
-  let userMessage;
-  if (pastedImage) {
-    userMessage = createUserMessage([
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: pastedImage
-        }
-      },
-      {
-        type: "text",
-        text: isKodingRequest && kodingContextInfo ? `${kodingContextInfo}
-
-${input}` : input
-      }
-    ]);
-  } else {
-    let processedInput = isKodingRequest && kodingContextInfo ? `${kodingContextInfo}
-
-${input}` : input;
-    if (input.includes("!`") || input.includes("@")) {
-      try {
-        const { executeBashCommands } = await import("../services/customCommands.js");
-        if (input.includes("!`")) {
-          processedInput = await executeBashCommands(processedInput);
-        }
-        if (input.includes("@")) {
-          const { processMentions } = await import("../services/mentionProcessor.js");
-          await processMentions(input);
-        }
-      } catch (error) {
-        console.warn("Dynamic content processing failed:", error);
-      }
-    }
-    userMessage = createUserMessage(processedInput);
-  }
-  if (isKodingRequest) {
-    userMessage.options = {
-      ...userMessage.options,
-      isKodingRequest: true
-    };
-  }
-  return [userMessage];
-}
-async function getMessagesForSlashCommand(commandName, args, setToolJSX, context) {
-  try {
-    const command = getCommand(commandName, context.options.commands);
-    switch (command.type) {
-      case "local-jsx": {
-        return new Promise((resolve2) => {
-          command.call(
-            (r) => {
-              setToolJSX(null);
-              resolve2([
-                createUserMessage(`<command-name>${command.userFacingName()}</command-name>
-          <command-message>${command.userFacingName()}</command-message>
-          <command-args>${args}</command-args>`),
-                r ? createAssistantMessage(r) : createAssistantMessage(NO_RESPONSE_REQUESTED)
-              ]);
-            },
-            context,
-            args
-          ).then((jsx) => {
-            if (jsx == null) return;
-            setToolJSX({
-              jsx,
-              shouldHidePromptInput: command.hidePromptInput ?? false
-            });
-          });
-        });
-      }
-      case "local": {
-        const userMessage = createUserMessage(`<command-name>${command.userFacingName()}</command-name>
-        <command-message>${command.userFacingName()}</command-message>
-        <command-args>${args}</command-args>`);
-        try {
-          const result = await command.call(args, {
-            ...context,
-            options: {
-              commands: context.options.commands || [],
-              tools: context.options.tools || [],
-              slowAndCapableModel: context.options.slowAndCapableModel || "main"
-            }
-          });
-          return [
-            userMessage,
-            createAssistantMessage(
-              `<local-command-stdout>${result}</local-command-stdout>`
-            )
-          ];
-        } catch (e) {
-          logError(e);
-          return [
-            userMessage,
-            createAssistantMessage(
-              `<local-command-stderr>${String(e)}</local-command-stderr>`
-            )
-          ];
-        }
-      }
-      case "prompt": {
-        const prompt = await command.getPromptForCommand(args);
-        return prompt.map((msg) => {
-          const userMessage = createUserMessage(
-            typeof msg.content === "string" ? msg.content : msg.content.map((block) => block.type === "text" ? block.text : "").join("\n")
-          );
-          userMessage.options = {
-            ...userMessage.options,
-            isCustomCommand: true,
-            commandName: command.userFacingName(),
-            commandArgs: args
-          };
-          return userMessage;
-        });
-      }
-    }
-  } catch (e) {
-    if (e instanceof MalformedCommandError) {
-      return [createAssistantMessage(e.message)];
-    }
-    throw e;
-  }
-}
-function extractTagFromMessage(message, tagName) {
-  if (message.type === "progress") {
-    return null;
-  }
-  if (typeof message.message.content !== "string") {
-    return null;
-  }
-  return extractTag(message.message.content, tagName);
-}
-function extractTag(html, tagName) {
-  if (!html.trim() || !tagName.trim()) {
-    return null;
-  }
-  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(
-    `<${escapedTag}(?:\\s+[^>]*)?>([\\s\\S]*?)<\\/${escapedTag}>`,
-    // Closing tag
-    "gi"
-  );
-  let match;
-  let depth = 0;
-  let lastIndex = 0;
-  const openingTag = new RegExp(`<${escapedTag}(?:\\s+[^>]*?)?>`, "gi");
-  const closingTag = new RegExp(`<\\/${escapedTag}>`, "gi");
-  while ((match = pattern.exec(html)) !== null) {
-    const content = match[1];
-    const beforeMatch = html.slice(lastIndex, match.index);
-    depth = 0;
-    openingTag.lastIndex = 0;
-    while (openingTag.exec(beforeMatch) !== null) {
-      depth++;
-    }
-    closingTag.lastIndex = 0;
-    while (closingTag.exec(beforeMatch) !== null) {
-      depth--;
-    }
-    if (depth === 0 && content) {
-      return content;
-    }
-    lastIndex = match.index + match[0].length;
-  }
-  return null;
-}
-function isNotEmptyMessage(message) {
-  if (message.type === "progress") {
-    return true;
-  }
-  if (typeof message.message.content === "string") {
-    return message.message.content.trim().length > 0;
-  }
-  if (message.message.content.length === 0) {
-    return false;
-  }
-  if (message.message.content.length > 1) {
-    return true;
-  }
-  if (message.message.content[0].type !== "text") {
-    return true;
-  }
-  return message.message.content[0].text.trim().length > 0 && message.message.content[0].text !== NO_CONTENT_MESSAGE && message.message.content[0].text !== INTERRUPT_MESSAGE_FOR_TOOL_USE;
-}
-function deterministicUUID(seed) {
-  const hash = createHash("sha256").update(seed).digest("hex");
-  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-${(parseInt(hash.slice(16, 17), 16) & 3 | 8).toString(16)}${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
-}
-function normalizeMessages(messages) {
-  return messages.flatMap((message, messageIndex) => {
-    if (message.type === "progress") {
-      return [message];
-    }
-    if (typeof message.message.content === "string") {
-      return [message];
-    }
-    return message.message.content.map((_, contentIndex) => {
-      switch (message.type) {
-        case "assistant":
-          const baseUuid = message.uuid || `msg-${messageIndex}`;
-          const contentId = _.type === "tool_use" ? _.id || contentIndex : contentIndex;
-          const stableUuid = deterministicUUID(`${baseUuid}-${contentId}`);
-          return {
-            type: "assistant",
-            uuid: stableUuid,
-            // Preserve original UUID for identifying parallel tool calls from same message
-            originalUuid: message.uuid,
-            message: {
-              ...message.message,
-              content: [_]
-            },
-            costUSD: message.costUSD / message.message.content.length,
-            durationMs: message.durationMs
-          };
-        case "user":
-          return message;
-      }
-    });
-  });
-}
-function isToolUseRequestMessage(message) {
-  return message.type === "assistant" && "costUSD" in message && // Note: stop_reason === 'tool_use' is unreliable -- it's not always set correctly
-  message.message.content.some((_) => _.type === "tool_use");
-}
-function reorderMessages(messages) {
-  const ms = [];
-  const toolUseMessages = [];
-  for (const message of messages) {
-    if (isToolUseRequestMessage(message)) {
-      toolUseMessages.push(message);
-    }
-    if (message.type === "progress") {
-      const existingProgressMessage = ms.find(
-        (_) => _.type === "progress" && _.toolUseID === message.toolUseID
-      );
-      if (existingProgressMessage) {
-        ms[ms.indexOf(existingProgressMessage)] = message;
-        continue;
-      }
-      const toolUseMessage = toolUseMessages.find(
-        (_) => _.message.content[0]?.id === message.toolUseID
-      );
-      if (toolUseMessage) {
-        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
-        continue;
-      }
-    }
-    if (message.type === "user" && Array.isArray(message.message.content) && message.message.content[0]?.type === "tool_result") {
-      const toolUseID = message.message.content[0]?.tool_use_id;
-      const lastProgressMessage = ms.find(
-        (_) => _.type === "progress" && _.toolUseID === toolUseID
-      );
-      if (lastProgressMessage) {
-        ms.splice(ms.indexOf(lastProgressMessage) + 1, 0, message);
-        continue;
-      }
-      const toolUseMessage = toolUseMessages.find(
-        (_) => _.message.content[0]?.id === toolUseID
-      );
-      if (toolUseMessage) {
-        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
-        continue;
-      }
-    } else {
-      ms.push(message);
-    }
-  }
-  return ms;
-}
-const getToolResultIDs = memoizeWithLimit(
-  (normalizedMessages) => Object.fromEntries(
-    normalizedMessages.flatMap(
-      (_) => _.type === "user" && _.message.content[0]?.type === "tool_result" ? [
-        [
-          _.message.content[0].tool_use_id,
-          _.message.content[0].is_error ?? false
-        ]
-      ] : []
-    )
-  ),
-  { max: 50, ttl: 3e4 }
-  // Keep last 50 results for 30 seconds
-);
-function getUnresolvedToolUseIDs(normalizedMessages) {
-  const toolResults = getToolResultIDs(normalizedMessages);
-  return new Set(
-    normalizedMessages.filter(
-      (_) => _.type === "assistant" && Array.isArray(_.message.content) && _.message.content[0]?.type === "tool_use" && !(_.message.content[0]?.id in toolResults)
-    ).map((_) => _.message.content[0].id)
-  );
-}
-function getInProgressToolUseIDs(normalizedMessages) {
-  const unresolvedToolUseIDs = getUnresolvedToolUseIDs(normalizedMessages);
-  const toolUseIDsThatHaveProgressMessages = new Set(
-    normalizedMessages.filter((_) => _.type === "progress").map((_) => _.toolUseID)
-  );
-  return new Set(
-    normalizedMessages.filter((_) => {
-      if (_.type !== "assistant") {
-        return false;
-      }
-      if (_.message.content[0]?.type !== "tool_use") {
-        return false;
-      }
-      const toolUseID = _.message.content[0].id;
-      if (toolUseID === unresolvedToolUseIDs.values().next().value) {
-        return true;
-      }
-      if (toolUseIDsThatHaveProgressMessages.has(toolUseID) && unresolvedToolUseIDs.has(toolUseID)) {
-        return true;
-      }
-      return false;
-    }).map((_) => _.message.content[0].id)
-  );
-}
-function getErroredToolUseMessages(normalizedMessages) {
-  const toolResults = getToolResultIDs(normalizedMessages);
-  return normalizedMessages.filter(
-    (_) => _.type === "assistant" && Array.isArray(_.message.content) && _.message.content[0]?.type === "tool_use" && _.message.content[0]?.id in toolResults && toolResults[_.message.content[0]?.id]
-  );
-}
-function normalizeMessagesForAPI(messages) {
-  const result = [];
-  messages.filter((_) => _.type !== "progress").forEach((message) => {
-    switch (message.type) {
-      case "user": {
-        if (!Array.isArray(message.message.content) || message.message.content[0]?.type !== "tool_result") {
-          result.push(message);
-          return;
-        }
-        const lastMessage = last(result);
-        if (!lastMessage || lastMessage?.type === "assistant" || !Array.isArray(lastMessage.message.content) || lastMessage.message.content[0]?.type !== "tool_result") {
-          result.push(message);
-          return;
-        }
-        result[result.indexOf(lastMessage)] = {
-          ...lastMessage,
-          message: {
-            ...lastMessage.message,
-            content: [
-              ...lastMessage.message.content,
-              ...message.message.content
-            ]
-          }
-        };
-        return;
-      }
-      case "assistant":
-        result.push(message);
-        return;
-    }
-  });
-  return result;
-}
-function normalizeContentFromAPI(content) {
-  const filteredContent = content.filter(
-    (_) => _.type !== "text" || _.text.trim().length > 0
-  );
-  if (filteredContent.length === 0) {
-    return [{ type: "text", text: NO_CONTENT_MESSAGE, citations: [] }];
-  }
-  return filteredContent;
-}
-function isEmptyMessageText(text) {
-  return stripSystemMessages(text).trim() === "" || text.trim() === NO_CONTENT_MESSAGE;
-}
-const STRIPPED_TAGS = [
-  "commit_analysis",
-  "context",
-  "function_analysis",
-  "pr_analysis"
-];
-function stripSystemMessages(content) {
-  const regex = new RegExp(`<(${STRIPPED_TAGS.join("|")})>.*?</\\1>
-?`, "gs");
-  return content.replace(regex, "").trim();
-}
-function getToolUseID(message) {
-  switch (message.type) {
-    case "assistant":
-      if (message.message.content[0]?.type !== "tool_use") {
-        return null;
-      }
-      return message.message.content[0].id;
-    case "user":
-      if (message.message.content[0]?.type !== "tool_result") {
-        return null;
-      }
-      return message.message.content[0].tool_use_id;
-    case "progress":
-      return message.toolUseID;
-  }
-}
-function getLastAssistantMessageId(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (message && message.type === "assistant") {
-      return message.message.id;
-    }
-  }
-  return void 0;
-}
-export {
-  CANCEL_MESSAGE,
-  INTERRUPT_MESSAGE,
-  INTERRUPT_MESSAGE_FOR_TOOL_USE,
-  NO_RESPONSE_REQUESTED,
-  REJECT_MESSAGE,
-  SYNTHETIC_ASSISTANT_MESSAGES,
-  createAssistantAPIErrorMessage,
-  createAssistantMessage,
-  createProgressMessage,
-  createToolResultStopMessage,
-  createUserMessage,
-  extractTag,
-  extractTagFromMessage,
-  getErroredToolUseMessages,
-  getInProgressToolUseIDs,
-  getLastAssistantMessageId,
-  getToolUseID,
-  getUnresolvedToolUseIDs,
-  isEmptyMessageText,
-  isNotEmptyMessage,
-  normalizeContentFromAPI,
-  normalizeMessages,
-  normalizeMessagesForAPI,
-  processUserInput,
-  reorderMessages,
-  stripSystemMessages
-};
-//# sourceMappingURL=messages.js.map