@xelauvas/xela-cli 0.1.0

package/src/components/messages/UserToolResultMessage/UserToolErrorMessage.tsx

@@ -0,0 +1,103 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import { BULLET_OPERATOR } from '../../../constants/figures.js';
+import { Text } from '../../../ink.js';
+import { filterToolProgressMessages, type Tool, type Tools } from '../../../Tool.js';
+import type { ProgressMessage } from '../../../types/message.js';
+import { INTERRUPT_MESSAGE_FOR_TOOL_USE, isClassifierDenial, PLAN_REJECTION_PREFIX, REJECT_MESSAGE_WITH_REASON_PREFIX } from '../../../utils/messages.js';
+import { FallbackToolUseErrorMessage } from '../../FallbackToolUseErrorMessage.js';
+import { InterruptedByUser } from '../../InterruptedByUser.js';
+import { MessageResponse } from '../../MessageResponse.js';
+import { RejectedPlanMessage } from './RejectedPlanMessage.js';
+import { RejectedToolUseMessage } from './RejectedToolUseMessage.js';
+type Props = {
+  progressMessagesForMessage: ProgressMessage[];
+  tool?: Tool; // undefined when resuming an old conversation that uses an old tool
+  tools: Tools;
+  param: ToolResultBlockParam;
+  verbose: boolean;
+  isTranscriptMode?: boolean;
+};
+export function UserToolErrorMessage(t0) {
+  const $ = _c(14);
+  const {
+    progressMessagesForMessage,
+    tool,
+    tools,
+    param,
+    verbose,
+    isTranscriptMode
+  } = t0;
+  if (typeof param.content === "string" && param.content.includes(INTERRUPT_MESSAGE_FOR_TOOL_USE)) {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <MessageResponse height={1}><InterruptedByUser /></MessageResponse>;
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    return t1;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(PLAN_REJECTION_PREFIX)) {
+    let t1;
+    if ($[1] !== param.content) {
+      t1 = param.content.substring(PLAN_REJECTION_PREFIX.length);
+      $[1] = param.content;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    const planContent = t1;
+    let t2;
+    if ($[3] !== planContent) {
+      t2 = <RejectedPlanMessage plan={planContent} />;
+      $[3] = planContent;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    return t2;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(REJECT_MESSAGE_WITH_REASON_PREFIX)) {
+    let t1;
+    if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <RejectedToolUseMessage />;
+      $[5] = t1;
+    } else {
+      t1 = $[5];
+    }
+    return t1;
+  }
+  if (feature("TRANSCRIPT_CLASSIFIER") && typeof param.content === "string" && isClassifierDenial(param.content)) {
+    let t1;
+    if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <MessageResponse height={1}><Text dimColor={true}>Denied by auto mode classifier {BULLET_OPERATOR} /feedback if incorrect</Text></MessageResponse>;
+      $[6] = t1;
+    } else {
+      t1 = $[6];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[7] !== isTranscriptMode || $[8] !== param.content || $[9] !== progressMessagesForMessage || $[10] !== tool || $[11] !== tools || $[12] !== verbose) {
+    t1 = tool?.renderToolUseErrorMessage?.(param.content, {
+      progressMessagesForMessage: filterToolProgressMessages(progressMessagesForMessage),
+      tools,
+      verbose,
+      isTranscriptMode
+    }) ?? <FallbackToolUseErrorMessage result={param.content} verbose={verbose} />;
+    $[7] = isTranscriptMode;
+    $[8] = param.content;
+    $[9] = progressMessagesForMessage;
+    $[10] = tool;
+    $[11] = tools;
+    $[12] = verbose;
+    $[13] = t1;
+  } else {
+    t1 = $[13];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","ToolResultBlockParam","React","BULLET_OPERATOR","Text","filterToolProgressMessages","Tool","Tools","ProgressMessage","INTERRUPT_MESSAGE_FOR_TOOL_USE","isClassifierDenial","PLAN_REJECTION_PREFIX","REJECT_MESSAGE_WITH_REASON_PREFIX","FallbackToolUseErrorMessage","InterruptedByUser","MessageResponse","RejectedPlanMessage","RejectedToolUseMessage","Props","progressMessagesForMessage","tool","tools","param","verbose","isTranscriptMode","UserToolErrorMessage","t0","$","_c","content","includes","t1","Symbol","for","startsWith","substring","length","planContent","t2","renderToolUseErrorMessage"],"sources":["UserToolErrorMessage.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport { BULLET_OPERATOR } from '../../../constants/figures.js'\nimport { Text } from '../../../ink.js'\nimport {\n  filterToolProgressMessages,\n  type Tool,\n  type Tools,\n} from '../../../Tool.js'\nimport type { ProgressMessage } from '../../../types/message.js'\nimport {\n  INTERRUPT_MESSAGE_FOR_TOOL_USE,\n  isClassifierDenial,\n  PLAN_REJECTION_PREFIX,\n  REJECT_MESSAGE_WITH_REASON_PREFIX,\n} from '../../../utils/messages.js'\nimport { FallbackToolUseErrorMessage } from '../../FallbackToolUseErrorMessage.js'\nimport { InterruptedByUser } from '../../InterruptedByUser.js'\nimport { MessageResponse } from '../../MessageResponse.js'\nimport { RejectedPlanMessage } from './RejectedPlanMessage.js'\nimport { RejectedToolUseMessage } from './RejectedToolUseMessage.js'\n\ntype Props = {\n  progressMessagesForMessage: ProgressMessage[]\n  tool?: Tool // undefined when resuming an old conversation that uses an old tool\n  tools: Tools\n  param: ToolResultBlockParam\n  verbose: boolean\n  isTranscriptMode?: boolean\n}\n\nexport function UserToolErrorMessage({\n  progressMessagesForMessage,\n  tool,\n  tools,\n  param,\n  verbose,\n  isTranscriptMode,\n}: Props): React.ReactNode {\n  if (\n    typeof param.content === 'string' &&\n    param.content.includes(INTERRUPT_MESSAGE_FOR_TOOL_USE)\n  ) {\n    return (\n      <MessageResponse height={1}>\n        <InterruptedByUser />\n      </MessageResponse>\n    )\n  }\n\n  if (\n    typeof param.content === 'string' &&\n    param.content.startsWith(PLAN_REJECTION_PREFIX)\n  ) {\n    // Extract the plan content from the error message\n    const planContent = param.content.substring(PLAN_REJECTION_PREFIX.length)\n    return <RejectedPlanMessage plan={planContent} />\n  }\n\n  if (\n    typeof param.content === 'string' &&\n    param.content.startsWith(REJECT_MESSAGE_WITH_REASON_PREFIX)\n  ) {\n    return <RejectedToolUseMessage />\n  }\n\n  if (\n    feature('TRANSCRIPT_CLASSIFIER') &&\n    typeof param.content === 'string' &&\n    isClassifierDenial(param.content)\n  ) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>\n          Denied by auto mode classifier {BULLET_OPERATOR} /feedback if\n          incorrect\n        </Text>\n      </MessageResponse>\n    )\n  }\n\n  return (\n    tool?.renderToolUseErrorMessage?.(param.content, {\n      progressMessagesForMessage: filterToolProgressMessages(\n        progressMessagesForMessage,\n      ),\n      tools,\n      verbose,\n      isTranscriptMode,\n    }) ?? (\n      <FallbackToolUseErrorMessage result={param.content} verbose={verbose} />\n    )\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/messages/UserToolResultMessage/UserToolRejectMessage.tsx

@@ -0,0 +1,95 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useTerminalSize } from '../../../hooks/useTerminalSize.js';
+import { useTheme } from '../../../ink.js';
+import { filterToolProgressMessages, type Tool, type Tools } from '../../../Tool.js';
+import type { ProgressMessage } from '../../../types/message.js';
+import type { buildMessageLookups } from '../../../utils/messages.js';
+import { FallbackToolUseRejectedMessage } from '../../FallbackToolUseRejectedMessage.js';
+type Props = {
+  input: {
+    [key: string]: unknown;
+  };
+  progressMessagesForMessage: ProgressMessage[];
+  style?: 'condensed';
+  tool?: Tool;
+  tools: Tools;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  verbose: boolean;
+  isTranscriptMode?: boolean;
+};
+export function UserToolRejectMessage(t0) {
+  const $ = _c(13);
+  const {
+    input,
+    progressMessagesForMessage,
+    style,
+    tool,
+    tools,
+    verbose,
+    isTranscriptMode
+  } = t0;
+  const {
+    columns
+  } = useTerminalSize();
+  const [theme] = useTheme();
+  if (!tool || !tool.renderToolUseRejectedMessage) {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <FallbackToolUseRejectedMessage />;
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    return t1;
+  }
+  const t1 = tool.inputSchema;
+  let t2;
+  let t3;
+  if ($[1] !== columns || $[2] !== input || $[3] !== isTranscriptMode || $[4] !== progressMessagesForMessage || $[5] !== style || $[6] !== theme || $[7] !== tool || $[8] !== tools || $[9] !== verbose) {
+    t3 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const parsedInput = t1.safeParse(input);
+      if (!parsedInput.success) {
+        let t4;
+        if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+          t4 = <FallbackToolUseRejectedMessage />;
+          $[12] = t4;
+        } else {
+          t4 = $[12];
+        }
+        t3 = t4;
+        break bb0;
+      }
+      t2 = tool.renderToolUseRejectedMessage(parsedInput.data, {
+        columns,
+        messages: [],
+        tools,
+        verbose,
+        progressMessagesForMessage: filterToolProgressMessages(progressMessagesForMessage),
+        style,
+        theme,
+        isTranscriptMode
+      }) ?? <FallbackToolUseRejectedMessage />;
+    }
+    $[1] = columns;
+    $[2] = input;
+    $[3] = isTranscriptMode;
+    $[4] = progressMessagesForMessage;
+    $[5] = style;
+    $[6] = theme;
+    $[7] = tool;
+    $[8] = tools;
+    $[9] = verbose;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t2 = $[10];
+    t3 = $[11];
+  }
+  if (t3 !== Symbol.for("react.early_return_sentinel")) {
+    return t3;
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZVRlcm1pbmFsU2l6ZSIsInVzZVRoZW1lIiwiZmlsdGVyVG9vbFByb2dyZXNzTWVzc2FnZXMiLCJUb29sIiwiVG9vbHMiLCJQcm9ncmVzc01lc3NhZ2UiLCJidWlsZE1lc3NhZ2VMb29rdXBzIiwiRmFsbGJhY2tUb29sVXNlUmVqZWN0ZWRNZXNzYWdlIiwiUHJvcHMiLCJpbnB1dCIsImtleSIsInByb2dyZXNzTWVzc2FnZXNGb3JNZXNzYWdlIiwic3R5bGUiLCJ0b29sIiwidG9vbHMiLCJsb29rdXBzIiwiUmV0dXJuVHlwZSIsInZlcmJvc2UiLCJpc1RyYW5zY3JpcHRNb2RlIiwiVXNlclRvb2xSZWplY3RNZXNzYWdlIiwidDAiLCIkIiwiX2MiLCJjb2x1bW5zIiwidGhlbWUiLCJyZW5kZXJUb29sVXNlUmVqZWN0ZWRNZXNzYWdlIiwidDEiLCJTeW1ib2wiLCJmb3IiLCJpbnB1dFNjaGVtYSIsInQyIiwidDMiLCJiYjAiLCJwYXJzZWRJbnB1dCIsInNhZmVQYXJzZSIsInN1Y2Nlc3MiLCJ0NCIsImRhdGEiLCJtZXNzYWdlcyJdLCJzb3VyY2VzIjpbIlVzZXJUb29sUmVqZWN0TWVzc2FnZS50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5pbXBvcnQgeyB1c2VUZXJtaW5hbFNpemUgfSBmcm9tICcuLi8uLi8uLi9ob29rcy91c2VUZXJtaW5hbFNpemUuanMnXG5pbXBvcnQgeyB1c2VUaGVtZSB9IGZyb20gJy4uLy4uLy4uL2luay5qcydcbmltcG9ydCB7XG4gIGZpbHRlclRvb2xQcm9ncmVzc01lc3NhZ2VzLFxuICB0eXBlIFRvb2wsXG4gIHR5cGUgVG9vbHMsXG59IGZyb20gJy4uLy4uLy4uL1Rvb2wuanMnXG5pbXBvcnQgdHlwZSB7IFByb2dyZXNzTWVzc2FnZSB9IGZyb20gJy4uLy4uLy4uL3R5cGVzL21lc3NhZ2UuanMnXG5pbXBvcnQgdHlwZSB7IGJ1aWxkTWVzc2FnZUxvb2t1cHMgfSBmcm9tICcuLi8uLi8uLi91dGlscy9tZXNzYWdlcy5qcydcbmltcG9ydCB7IEZhbGxiYWNrVG9vbFVzZVJlamVjdGVkTWVzc2FnZSB9IGZyb20gJy4uLy4uL0ZhbGxiYWNrVG9vbFVzZVJlamVjdGVkTWVzc2FnZS5qcydcblxudHlwZSBQcm9wcyA9IHtcbiAgaW5wdXQ6IHsgW2tleTogc3RyaW5nXTogdW5rbm93biB9XG4gIHByb2dyZXNzTWVzc2FnZXNGb3JNZXNzYWdlOiBQcm9ncmVzc01lc3NhZ2VbXVxuICBzdHlsZT86ICdjb25kZW5zZWQnXG4gIHRvb2w/OiBUb29sXG4gIHRvb2xzOiBUb29sc1xuICBsb29rdXBzOiBSZXR1cm5UeXBlPHR5cGVvZiBidWlsZE1lc3NhZ2VMb29rdXBzPlxuICB2ZXJib3NlOiBib29sZWFuXG4gIGlzVHJhbnNjcmlwdE1vZGU/OiBib29sZWFuXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBVc2VyVG9vbFJlamVjdE1lc3NhZ2Uoe1xuICBpbnB1dCxcbiAgcHJvZ3Jlc3NNZXNzYWdlc0Zvck1lc3NhZ2UsXG4gIHN0eWxlLFxuICB0b29sLFxuICB0b29scyxcbiAgdmVyYm9zZSxcbiAgaXNUcmFuc2NyaXB0TW9kZSxcbn06IFByb3BzKTogUmVhY3QuUmVhY3ROb2RlIHtcbiAgY29uc3QgeyBjb2x1bW5zIH0gPSB1c2VUZXJtaW5hbFNpemUoKVxuICBjb25zdCBbdGhlbWVdID0gdXNlVGhlbWUoKVxuXG4gIGlmICghdG9vbCB8fCAhdG9vbC5yZW5kZXJUb29sVXNlUmVqZWN0ZWRNZXNzYWdlKSB7XG4gICAgcmV0dXJuIDxGYWxsYmFja1Rvb2xVc2VSZWplY3RlZE1lc3NhZ2UgLz5cbiAgfVxuXG4gIGNvbnN0IHBhcnNlZElucHV0ID0gdG9vbC5pbnB1dFNjaGVtYS5zYWZlUGFyc2UoaW5wdXQpXG4gIGlmICghcGFyc2VkSW5wdXQuc3VjY2Vzcykge1xuICAgIHJldHVybiA8RmFsbGJhY2tUb29sVXNlUmVqZWN0ZWRNZXNzYWdlIC8+XG4gIH1cblxuICByZXR1cm4gKFxuICAgIHRvb2wucmVuZGVyVG9vbFVzZVJlamVjdGVkTWVzc2FnZShwYXJzZWRJbnB1dC5kYXRhLCB7XG4gICAgICBjb2x1bW5zLFxuICAgICAgbWVzc2FnZXM6IFtdLFxuICAgICAgdG9vbHMsXG4gICAgICB2ZXJib3NlLFxuICAgICAgcHJvZ3Jlc3NNZXNzYWdlc0Zvck1lc3NhZ2U6IGZpbHRlclRvb2xQcm9ncmVzc01lc3NhZ2VzKFxuICAgICAgICBwcm9ncmVzc01lc3NhZ2VzRm9yTWVzc2FnZSxcbiAgICAgICksXG4gICAgICBzdHlsZSxcbiAgICAgIHRoZW1lLFxuICAgICAgaXNUcmFuc2NyaXB0TW9kZSxcbiAgICB9KSA/PyA8RmFsbGJhY2tUb29sVXNlUmVqZWN0ZWRNZXNzYWdlIC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsU0FBU0MsZUFBZSxRQUFRLG1DQUFtQztBQUNuRSxTQUFTQyxRQUFRLFFBQVEsaUJBQWlCO0FBQzFDLFNBQ0VDLDBCQUEwQixFQUMxQixLQUFLQyxJQUFJLEVBQ1QsS0FBS0MsS0FBSyxRQUNMLGtCQUFrQjtBQUN6QixjQUFjQyxlQUFlLFFBQVEsMkJBQTJCO0FBQ2hFLGNBQWNDLG1CQUFtQixRQUFRLDRCQUE0QjtBQUNyRSxTQUFTQyw4QkFBOEIsUUFBUSx5Q0FBeUM7QUFFeEYsS0FBS0MsS0FBSyxHQUFHO0VBQ1hDLEtBQUssRUFBRTtJQUFFLENBQUNDLEdBQUcsRUFBRSxNQUFNLENBQUMsRUFBRSxPQUFPO0VBQUMsQ0FBQztFQUNqQ0MsMEJBQTBCLEVBQUVOLGVBQWUsRUFBRTtFQUM3Q08sS0FBSyxDQUFDLEVBQUUsV0FBVztFQUNuQkMsSUFBSSxDQUFDLEVBQUVWLElBQUk7RUFDWFcsS0FBSyxFQUFFVixLQUFLO0VBQ1pXLE9BQU8sRUFBRUMsVUFBVSxDQUFDLE9BQU9WLG1CQUFtQixDQUFDO0VBQy9DVyxPQUFPLEVBQUUsT0FBTztFQUNoQkMsZ0JBQWdCLENBQUMsRUFBRSxPQUFPO0FBQzVCLENBQUM7QUFFRCxPQUFPLFNBQUFDLHNCQUFBQyxFQUFBO0VBQUEsTUFBQUMsQ0FBQSxHQUFBQyxFQUFBO0VBQStCO0lBQUFiLEtBQUE7SUFBQUUsMEJBQUE7SUFBQUMsS0FBQTtJQUFBQyxJQUFBO0lBQUFDLEtBQUE7SUFBQUcsT0FBQTtJQUFBQztFQUFBLElBQUFFLEVBUTlCO0VBQ047SUFBQUc7RUFBQSxJQUFvQnZCLGVBQWUsQ0FBQyxDQUFDO0VBQ3JDLE9BQUF3QixLQUFBLElBQWdCdkIsUUFBUSxDQUFDLENBQUM7RUFFMUIsSUFBSSxDQUFDWSxJQUEwQyxJQUEzQyxDQUFVQSxJQUFJLENBQUFZLDRCQUE2QjtJQUFBLElBQUFDLEVBQUE7SUFBQSxJQUFBTCxDQUFBLFFBQUFNLE1BQUEsQ0FBQUMsR0FBQTtNQUN0Q0YsRUFBQSxJQUFDLDhCQUE4QixHQUFHO01BQUFMLENBQUEsTUFBQUssRUFBQTtJQUFBO01BQUFBLEVBQUEsR0FBQUwsQ0FBQTtJQUFBO0lBQUEsT0FBbENLLEVBQWtDO0VBQUE7RUFHdkIsTUFBQUEsRUFBQSxHQUFBYixJQUFJLENBQUFnQixXQUFZO0VBQUEsSUFBQUMsRUFBQTtFQUFBLElBQUFDLEVBQUE7RUFBQSxJQUFBVixDQUFBLFFBQUFFLE9BQUEsSUFBQUYsQ0FBQSxRQUFBWixLQUFBLElBQUFZLENBQUEsUUFBQUgsZ0JBQUEsSUFBQUcsQ0FBQSxRQUFBViwwQkFBQSxJQUFBVSxDQUFBLFFBQUFULEtBQUEsSUFBQVMsQ0FBQSxRQUFBRyxLQUFBLElBQUFILENBQUEsUUFBQVIsSUFBQSxJQUFBUSxDQUFBLFFBQUFQLEtBQUEsSUFBQU8sQ0FBQSxRQUFBSixPQUFBO0lBRTNCYyxFQUFBLEdBQUFKLE1BQWtDLENBQUFDLEdBQUEsQ0FBbEMsNkJBQWlDLENBQUM7SUFBQUksR0FBQTtNQUYzQyxNQUFBQyxXQUFBLEdBQW9CUCxFQUFnQixDQUFBUSxTQUFVLENBQUN6QixLQUFLLENBQUM7TUFDckQsSUFBSSxDQUFDd0IsV0FBVyxDQUFBRSxPQUFRO1FBQUEsSUFBQUMsRUFBQTtRQUFBLElBQUFmLENBQUEsU0FBQU0sTUFBQSxDQUFBQyxHQUFBO1VBQ2ZRLEVBQUEsSUFBQyw4QkFBOEIsR0FBRztVQUFBZixDQUFBLE9BQUFlLEVBQUE7UUFBQTtVQUFBQSxFQUFBLEdBQUFmLENBQUE7UUFBQTtRQUFsQ1UsRUFBQSxHQUFBSyxFQUFrQztRQUFsQyxNQUFBSixHQUFBO01BQWtDO01BSXpDRixFQUFBLEdBQUFqQixJQUFJLENBQUFZLDRCQUE2QixDQUFDUSxXQUFXLENBQUFJLElBQUssRUFBRTtRQUFBZCxPQUFBO1FBQUFlLFFBQUEsRUFFeEMsRUFBRTtRQUFBeEIsS0FBQTtRQUFBRyxPQUFBO1FBQUFOLDBCQUFBLEVBR2dCVCwwQkFBMEIsQ0FDcERTLDBCQUNGLENBQUM7UUFBQUMsS0FBQTtRQUFBWSxLQUFBO1FBQUFOO01BSUgsQ0FBdUMsQ0FBQyxJQUFsQyxDQUFDLDhCQUE4QixHQUFHO0lBQUE7SUFBQUcsQ0FBQSxNQUFBRSxPQUFBO0lBQUFGLENBQUEsTUFBQVosS0FBQTtJQUFBWSxDQUFBLE1BQUFILGdCQUFBO0lBQUFHLENBQUEsTUFBQVYsMEJBQUE7SUFBQVUsQ0FBQSxNQUFBVCxLQUFBO0lBQUFTLENBQUEsTUFBQUcsS0FBQTtJQUFBSCxDQUFBLE1BQUFSLElBQUE7SUFBQVEsQ0FBQSxNQUFBUCxLQUFBO0lBQUFPLENBQUEsTUFBQUosT0FBQTtJQUFBSSxDQUFBLE9BQUFTLEVBQUE7SUFBQVQsQ0FBQSxPQUFBVSxFQUFBO0VBQUE7SUFBQUQsRUFBQSxHQUFBVCxDQUFBO0lBQUFVLEVBQUEsR0FBQVYsQ0FBQTtFQUFBO0VBQUEsSUFBQVUsRUFBQSxLQUFBSixNQUFBLENBQUFDLEdBQUE7SUFBQSxPQUFBRyxFQUFBO0VBQUE7RUFBQSxPQVh4Q0QsRUFXd0M7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/src/components/messages/UserToolResultMessage/UserToolResultMessage.tsx

@@ -0,0 +1,106 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import type { Tools } from '../../../Tool.js';
+import type { NormalizedUserMessage, ProgressMessage } from '../../../types/message.js';
+import { type buildMessageLookups, CANCEL_MESSAGE, INTERRUPT_MESSAGE_FOR_TOOL_USE, REJECT_MESSAGE } from '../../../utils/messages.js';
+import { UserToolCanceledMessage } from './UserToolCanceledMessage.js';
+import { UserToolErrorMessage } from './UserToolErrorMessage.js';
+import { UserToolRejectMessage } from './UserToolRejectMessage.js';
+import { UserToolSuccessMessage } from './UserToolSuccessMessage.js';
+import { useGetToolFromMessages } from './utils.js';
+type Props = {
+  param: ToolResultBlockParam;
+  message: NormalizedUserMessage;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  progressMessagesForMessage: ProgressMessage[];
+  style?: 'condensed';
+  tools: Tools;
+  verbose: boolean;
+  width: number | string;
+  isTranscriptMode?: boolean;
+};
+export function UserToolResultMessage(t0) {
+  const $ = _c(28);
+  const {
+    param,
+    message,
+    lookups,
+    progressMessagesForMessage,
+    style,
+    tools,
+    verbose,
+    width,
+    isTranscriptMode
+  } = t0;
+  const toolUse = useGetToolFromMessages(param.tool_use_id, tools, lookups);
+  if (!toolUse) {
+    return null;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(CANCEL_MESSAGE)) {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <UserToolCanceledMessage />;
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    return t1;
+  }
+  if (typeof param.content === "string" && param.content.startsWith(REJECT_MESSAGE) || param.content === INTERRUPT_MESSAGE_FOR_TOOL_USE) {
+    const t1 = toolUse.toolUse.input as {
+      [key: string]: unknown;
+    };
+    let t2;
+    if ($[1] !== isTranscriptMode || $[2] !== lookups || $[3] !== progressMessagesForMessage || $[4] !== style || $[5] !== t1 || $[6] !== toolUse.tool || $[7] !== tools || $[8] !== verbose) {
+      t2 = <UserToolRejectMessage input={t1} progressMessagesForMessage={progressMessagesForMessage} tool={toolUse.tool} tools={tools} lookups={lookups} style={style} verbose={verbose} isTranscriptMode={isTranscriptMode} />;
+      $[1] = isTranscriptMode;
+      $[2] = lookups;
+      $[3] = progressMessagesForMessage;
+      $[4] = style;
+      $[5] = t1;
+      $[6] = toolUse.tool;
+      $[7] = tools;
+      $[8] = verbose;
+      $[9] = t2;
+    } else {
+      t2 = $[9];
+    }
+    return t2;
+  }
+  if (param.is_error) {
+    let t1;
+    if ($[10] !== isTranscriptMode || $[11] !== param || $[12] !== progressMessagesForMessage || $[13] !== toolUse.tool || $[14] !== tools || $[15] !== verbose) {
+      t1 = <UserToolErrorMessage progressMessagesForMessage={progressMessagesForMessage} tool={toolUse.tool} tools={tools} param={param} verbose={verbose} isTranscriptMode={isTranscriptMode} />;
+      $[10] = isTranscriptMode;
+      $[11] = param;
+      $[12] = progressMessagesForMessage;
+      $[13] = toolUse.tool;
+      $[14] = tools;
+      $[15] = verbose;
+      $[16] = t1;
+    } else {
+      t1 = $[16];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[17] !== isTranscriptMode || $[18] !== lookups || $[19] !== message || $[20] !== progressMessagesForMessage || $[21] !== style || $[22] !== toolUse.tool || $[23] !== toolUse.toolUse.id || $[24] !== tools || $[25] !== verbose || $[26] !== width) {
+    t1 = <UserToolSuccessMessage message={message} lookups={lookups} toolUseID={toolUse.toolUse.id} progressMessagesForMessage={progressMessagesForMessage} style={style} tool={toolUse.tool} tools={tools} verbose={verbose} width={width} isTranscriptMode={isTranscriptMode} />;
+    $[17] = isTranscriptMode;
+    $[18] = lookups;
+    $[19] = message;
+    $[20] = progressMessagesForMessage;
+    $[21] = style;
+    $[22] = toolUse.tool;
+    $[23] = toolUse.toolUse.id;
+    $[24] = tools;
+    $[25] = verbose;
+    $[26] = width;
+    $[27] = t1;
+  } else {
+    t1 = $[27];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","React","Tools","NormalizedUserMessage","ProgressMessage","buildMessageLookups","CANCEL_MESSAGE","INTERRUPT_MESSAGE_FOR_TOOL_USE","REJECT_MESSAGE","UserToolCanceledMessage","UserToolErrorMessage","UserToolRejectMessage","UserToolSuccessMessage","useGetToolFromMessages","Props","param","message","lookups","ReturnType","progressMessagesForMessage","style","tools","verbose","width","isTranscriptMode","UserToolResultMessage","t0","$","_c","toolUse","tool_use_id","content","startsWith","t1","Symbol","for","input","key","t2","tool","is_error","id"],"sources":["UserToolResultMessage.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport type { Tools } from '../../../Tool.js'\nimport type {\n  NormalizedUserMessage,\n  ProgressMessage,\n} from '../../../types/message.js'\nimport {\n  type buildMessageLookups,\n  CANCEL_MESSAGE,\n  INTERRUPT_MESSAGE_FOR_TOOL_USE,\n  REJECT_MESSAGE,\n} from '../../../utils/messages.js'\nimport { UserToolCanceledMessage } from './UserToolCanceledMessage.js'\nimport { UserToolErrorMessage } from './UserToolErrorMessage.js'\nimport { UserToolRejectMessage } from './UserToolRejectMessage.js'\nimport { UserToolSuccessMessage } from './UserToolSuccessMessage.js'\nimport { useGetToolFromMessages } from './utils.js'\n\ntype Props = {\n  param: ToolResultBlockParam\n  message: NormalizedUserMessage\n  lookups: ReturnType<typeof buildMessageLookups>\n  progressMessagesForMessage: ProgressMessage[]\n  style?: 'condensed'\n  tools: Tools\n  verbose: boolean\n  width: number | string\n  isTranscriptMode?: boolean\n}\n\nexport function UserToolResultMessage({\n  param,\n  message,\n  lookups,\n  progressMessagesForMessage,\n  style,\n  tools,\n  verbose,\n  width,\n  isTranscriptMode,\n}: Props): React.ReactNode {\n  const toolUse = useGetToolFromMessages(param.tool_use_id, tools, lookups)\n  if (!toolUse) {\n    return null\n  }\n\n  if (\n    typeof param.content === 'string' &&\n    param.content.startsWith(CANCEL_MESSAGE)\n  ) {\n    return <UserToolCanceledMessage />\n  }\n\n  if (\n    (typeof param.content === 'string' &&\n      param.content.startsWith(REJECT_MESSAGE)) ||\n    param.content === INTERRUPT_MESSAGE_FOR_TOOL_USE\n  ) {\n    return (\n      <UserToolRejectMessage\n        input={toolUse.toolUse.input as { [key: string]: unknown }}\n        progressMessagesForMessage={progressMessagesForMessage}\n        tool={toolUse.tool}\n        tools={tools}\n        lookups={lookups}\n        style={style}\n        verbose={verbose}\n        isTranscriptMode={isTranscriptMode}\n      />\n    )\n  }\n\n  if (param.is_error) {\n    return (\n      <UserToolErrorMessage\n        progressMessagesForMessage={progressMessagesForMessage}\n        tool={toolUse.tool}\n        tools={tools}\n        param={param}\n        verbose={verbose}\n        isTranscriptMode={isTranscriptMode}\n      />\n    )\n  }\n\n  return (\n    <UserToolSuccessMessage\n      message={message}\n      lookups={lookups}\n      toolUseID={toolUse.toolUse.id}\n      progressMessagesForMessage={progressMessagesForMessage}\n      style={style}\n      tool={toolUse.tool}\n      tools={tools}\n      verbose={verbose}\n      width={width}\n      isTranscriptMode={isTranscriptMode}\n    />\n  )\n}\n"],"mappings":";AAAA,cAAcA,oBAAoB,QAAQ,uCAAuC;AACjF,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,cAAcC,KAAK,QAAQ,kBAAkB;AAC7C,cACEC,qBAAqB,EACrBC,eAAe,QACV,2BAA2B;AAClC,SACE,KAAKC,mBAAmB,EACxBC,cAAc,EACdC,8BAA8B,EAC9BC,cAAc,QACT,4BAA4B;AACnC,SAASC,uBAAuB,QAAQ,8BAA8B;AACtE,SAASC,oBAAoB,QAAQ,2BAA2B;AAChE,SAASC,qBAAqB,QAAQ,4BAA4B;AAClE,SAASC,sBAAsB,QAAQ,6BAA6B;AACpE,SAASC,sBAAsB,QAAQ,YAAY;AAEnD,KAAKC,KAAK,GAAG;EACXC,KAAK,EAAEf,oBAAoB;EAC3BgB,OAAO,EAAEb,qBAAqB;EAC9Bc,OAAO,EAAEC,UAAU,CAAC,OAAOb,mBAAmB,CAAC;EAC/Cc,0BAA0B,EAAEf,eAAe,EAAE;EAC7CgB,KAAK,CAAC,EAAE,WAAW;EACnBC,KAAK,EAAEnB,KAAK;EACZoB,OAAO,EAAE,OAAO;EAChBC,KAAK,EAAE,MAAM,GAAG,MAAM;EACtBC,gBAAgB,CAAC,EAAE,OAAO;AAC5B,CAAC;AAED,OAAO,SAAAC,sBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAA+B;IAAAb,KAAA;IAAAC,OAAA;IAAAC,OAAA;IAAAE,0BAAA;IAAAC,KAAA;IAAAC,KAAA;IAAAC,OAAA;IAAAC,KAAA;IAAAC;EAAA,IAAAE,EAU9B;EACN,MAAAG,OAAA,GAAgBhB,sBAAsB,CAACE,KAAK,CAAAe,WAAY,EAAET,KAAK,EAAEJ,OAAO,CAAC;EACzE,IAAI,CAACY,OAAO;IAAA,OACH,IAAI;EAAA;EAGb,IACE,OAAOd,KAAK,CAAAgB,OAAQ,KAAK,QACe,IAAxChB,KAAK,CAAAgB,OAAQ,CAAAC,UAAW,CAAC1B,cAAc,CAAC;IAAA,IAAA2B,EAAA;IAAA,IAAAN,CAAA,QAAAO,MAAA,CAAAC,GAAA;MAEjCF,EAAA,IAAC,uBAAuB,GAAG;MAAAN,CAAA,MAAAM,EAAA;IAAA;MAAAA,EAAA,GAAAN,CAAA;IAAA;IAAA,OAA3BM,EAA2B;EAAA;EAGpC,IACG,OAAOlB,KAAK,CAAAgB,OAAQ,KAAK,QACgB,IAAxChB,KAAK,CAAAgB,OAAQ,CAAAC,UAAW,CAACxB,cAAc,CACO,IAAhDO,KAAK,CAAAgB,OAAQ,KAAKxB,8BAA8B;IAIrC,MAAA0B,EAAA,GAAAJ,OAAO,CAAAA,OAAQ,CAAAO,KAAM,IAAI;MAAE,CAACC,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO;IAAC,CAAC;IAAA,IAAAC,EAAA;IAAA,IAAAX,CAAA,QAAAH,gBAAA,IAAAG,CAAA,QAAAV,OAAA,IAAAU,CAAA,QAAAR,0BAAA,IAAAQ,CAAA,QAAAP,KAAA,IAAAO,CAAA,QAAAM,EAAA,IAAAN,CAAA,QAAAE,OAAA,CAAAU,IAAA,IAAAZ,CAAA,QAAAN,KAAA,IAAAM,CAAA,QAAAL,OAAA;MAD5DgB,EAAA,IAAC,qBAAqB,CACb,KAAmD,CAAnD,CAAAL,EAAkD,CAAC,CAC9Bd,0BAA0B,CAA1BA,2BAAyB,CAAC,CAChD,IAAY,CAAZ,CAAAU,OAAO,CAAAU,IAAI,CAAC,CACXlB,KAAK,CAALA,MAAI,CAAC,CACHJ,OAAO,CAAPA,QAAM,CAAC,CACTG,KAAK,CAALA,MAAI,CAAC,CACHE,OAAO,CAAPA,QAAM,CAAC,CACEE,gBAAgB,CAAhBA,iBAAe,CAAC,GAClC;MAAAG,CAAA,MAAAH,gBAAA;MAAAG,CAAA,MAAAV,OAAA;MAAAU,CAAA,MAAAR,0BAAA;MAAAQ,CAAA,MAAAP,KAAA;MAAAO,CAAA,MAAAM,EAAA;MAAAN,CAAA,MAAAE,OAAA,CAAAU,IAAA;MAAAZ,CAAA,MAAAN,KAAA;MAAAM,CAAA,MAAAL,OAAA;MAAAK,CAAA,MAAAW,EAAA;IAAA;MAAAA,EAAA,GAAAX,CAAA;IAAA;IAAA,OATFW,EASE;EAAA;EAIN,IAAIvB,KAAK,CAAAyB,QAAS;IAAA,IAAAP,EAAA;IAAA,IAAAN,CAAA,SAAAH,gBAAA,IAAAG,CAAA,SAAAZ,KAAA,IAAAY,CAAA,SAAAR,0BAAA,IAAAQ,CAAA,SAAAE,OAAA,CAAAU,IAAA,IAAAZ,CAAA,SAAAN,KAAA,IAAAM,CAAA,SAAAL,OAAA;MAEdW,EAAA,IAAC,oBAAoB,CACSd,0BAA0B,CAA1BA,2BAAyB,CAAC,CAChD,IAAY,CAAZ,CAAAU,OAAO,CAAAU,IAAI,CAAC,CACXlB,KAAK,CAALA,MAAI,CAAC,CACLN,KAAK,CAALA,MAAI,CAAC,CACHO,OAAO,CAAPA,QAAM,CAAC,CACEE,gBAAgB,CAAhBA,iBAAe,CAAC,GAClC;MAAAG,CAAA,OAAAH,gBAAA;MAAAG,CAAA,OAAAZ,KAAA;MAAAY,CAAA,OAAAR,0BAAA;MAAAQ,CAAA,OAAAE,OAAA,CAAAU,IAAA;MAAAZ,CAAA,OAAAN,KAAA;MAAAM,CAAA,OAAAL,OAAA;MAAAK,CAAA,OAAAM,EAAA;IAAA;MAAAA,EAAA,GAAAN,CAAA;IAAA;IAAA,OAPFM,EAOE;EAAA;EAEL,IAAAA,EAAA;EAAA,IAAAN,CAAA,SAAAH,gBAAA,IAAAG,CAAA,SAAAV,OAAA,IAAAU,CAAA,SAAAX,OAAA,IAAAW,CAAA,SAAAR,0BAAA,IAAAQ,CAAA,SAAAP,KAAA,IAAAO,CAAA,SAAAE,OAAA,CAAAU,IAAA,IAAAZ,CAAA,SAAAE,OAAA,CAAAA,OAAA,CAAAY,EAAA,IAAAd,CAAA,SAAAN,KAAA,IAAAM,CAAA,SAAAL,OAAA,IAAAK,CAAA,SAAAJ,KAAA;IAGCU,EAAA,IAAC,sBAAsB,CACZjB,OAAO,CAAPA,QAAM,CAAC,CACPC,OAAO,CAAPA,QAAM,CAAC,CACL,SAAkB,CAAlB,CAAAY,OAAO,CAAAA,OAAQ,CAAAY,EAAE,CAAC,CACDtB,0BAA0B,CAA1BA,2BAAyB,CAAC,CAC/CC,KAAK,CAALA,MAAI,CAAC,CACN,IAAY,CAAZ,CAAAS,OAAO,CAAAU,IAAI,CAAC,CACXlB,KAAK,CAALA,MAAI,CAAC,CACHC,OAAO,CAAPA,QAAM,CAAC,CACTC,KAAK,CAALA,MAAI,CAAC,CACMC,gBAAgB,CAAhBA,iBAAe,CAAC,GAClC;IAAAG,CAAA,OAAAH,gBAAA;IAAAG,CAAA,OAAAV,OAAA;IAAAU,CAAA,OAAAX,OAAA;IAAAW,CAAA,OAAAR,0BAAA;IAAAQ,CAAA,OAAAP,KAAA;IAAAO,CAAA,OAAAE,OAAA,CAAAU,IAAA;IAAAZ,CAAA,OAAAE,OAAA,CAAAA,OAAA,CAAAY,EAAA;IAAAd,CAAA,OAAAN,KAAA;IAAAM,CAAA,OAAAL,OAAA;IAAAK,CAAA,OAAAJ,KAAA;IAAAI,CAAA,OAAAM,EAAA;EAAA;IAAAA,EAAA,GAAAN,CAAA;EAAA;EAAA,OAXFM,EAWE;AAAA","ignoreList":[]}

package/src/components/messages/UserToolResultMessage/UserToolSuccessMessage.tsx

@@ -0,0 +1,104 @@
+import { feature } from 'bun:bundle';
+import figures from 'figures';
+import * as React from 'react';
+import { SentryErrorBoundary } from 'src/components/SentryErrorBoundary.js';
+import { Box, Text, useTheme } from '../../../ink.js';
+import { useAppState } from '../../../state/AppState.js';
+import { filterToolProgressMessages, type Tool, type Tools } from '../../../Tool.js';
+import type { NormalizedUserMessage, ProgressMessage } from '../../../types/message.js';
+import { deleteClassifierApproval, getClassifierApproval, getYoloClassifierApproval } from '../../../utils/classifierApprovals.js';
+import type { buildMessageLookups } from '../../../utils/messages.js';
+import { MessageResponse } from '../../MessageResponse.js';
+import { HookProgressMessage } from '../HookProgressMessage.js';
+type Props = {
+  message: NormalizedUserMessage;
+  lookups: ReturnType<typeof buildMessageLookups>;
+  toolUseID: string;
+  progressMessagesForMessage: ProgressMessage[];
+  style?: 'condensed';
+  tool?: Tool;
+  tools: Tools;
+  verbose: boolean;
+  width: number | string;
+  isTranscriptMode?: boolean;
+};
+export function UserToolSuccessMessage({
+  message,
+  lookups,
+  toolUseID,
+  progressMessagesForMessage,
+  style,
+  tool,
+  tools,
+  verbose,
+  width,
+  isTranscriptMode
+}: Props): React.ReactNode {
+  const [theme] = useTheme();
+  // Hook stays inside feature() ternary so external builds don't pay a
+  // per-scrollback-message store subscription — same pattern as
+  // UserPromptMessage.tsx.
+  const isBriefOnly = feature('KAIROS') || feature('KAIROS_BRIEF') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useAppState(s => s.isBriefOnly) : false;
+
+  // Capture classifier approval once on mount, then delete from Map to prevent linear growth.
+  // useState lazy initializer ensures the value persists across re-renders.
+  const [classifierRule] = React.useState(() => getClassifierApproval(toolUseID));
+  const [yoloReason] = React.useState(() => getYoloClassifierApproval(toolUseID));
+  React.useEffect(() => {
+    deleteClassifierApproval(toolUseID);
+  }, [toolUseID]);
+  if (!message.toolUseResult || !tool) {
+    return null;
+  }
+
+  // Resumed transcripts deserialize toolUseResult via raw JSON.parse with no
+  // validation (parseJSONL). A partial/corrupt/old-format result crashes
+  // renderToolResultMessage on first field access (anthropics/claude-code#39817).
+  // Validate against outputSchema before rendering — mirrors CollapsedReadSearchContent.
+  const parsedOutput = tool.outputSchema?.safeParse(message.toolUseResult);
+  if (parsedOutput && !parsedOutput.success) {
+    return null;
+  }
+  const toolResult = parsedOutput?.data ?? message.toolUseResult;
+  const renderedMessage = tool.renderToolResultMessage?.(toolResult as never, filterToolProgressMessages(progressMessagesForMessage), {
+    style,
+    theme,
+    tools,
+    verbose,
+    isTranscriptMode,
+    isBriefOnly,
+    input: lookups.toolUseByToolUseID.get(toolUseID)?.input
+  }) ?? null;
+
+  // Don't render anything if the tool result message is null
+  if (renderedMessage === null) {
+    return null;
+  }
+
+  // Tools that return '' from userFacingName opt out of tool chrome and
+  // render like plain assistant text. Skip the tool-result width constraint
+  // so MarkdownTable's SAFETY_MARGIN=4 (tuned for the assistant-text 2-col
+  // dot gutter) holds — otherwise tables wrap their box-drawing chars.
+  const rendersAsAssistantText = tool.userFacingName(undefined) === '';
+  return <Box flexDirection="column">
+      <Box flexDirection="column" width={rendersAsAssistantText ? undefined : width}>
+        {renderedMessage}
+        {feature('BASH_CLASSIFIER') ? classifierRule && <MessageResponse height={1}>
+                <Text dimColor>
+                  <Text color="success">{figures.tick}</Text>
+                  {' Auto-approved \u00b7 matched '}
+                  {`"${classifierRule}"`}
+                </Text>
+              </MessageResponse> : null}
+        {feature('TRANSCRIPT_CLASSIFIER') ? yoloReason && <MessageResponse height={1}>
+                <Text dimColor>Allowed by auto mode classifier</Text>
+              </MessageResponse> : null}
+      </Box>
+      <SentryErrorBoundary>
+        <HookProgressMessage hookEvent="PostToolUse" lookups={lookups} toolUseID={toolUseID} verbose={verbose} isTranscriptMode={isTranscriptMode} />
+      </SentryErrorBoundary>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","figures","React","SentryErrorBoundary","Box","Text","useTheme","useAppState","filterToolProgressMessages","Tool","Tools","NormalizedUserMessage","ProgressMessage","deleteClassifierApproval","getClassifierApproval","getYoloClassifierApproval","buildMessageLookups","MessageResponse","HookProgressMessage","Props","message","lookups","ReturnType","toolUseID","progressMessagesForMessage","style","tool","tools","verbose","width","isTranscriptMode","UserToolSuccessMessage","ReactNode","theme","isBriefOnly","s","classifierRule","useState","yoloReason","useEffect","toolUseResult","parsedOutput","outputSchema","safeParse","success","toolResult","data","renderedMessage","renderToolResultMessage","input","toolUseByToolUseID","get","rendersAsAssistantText","userFacingName","undefined","tick"],"sources":["UserToolSuccessMessage.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { SentryErrorBoundary } from 'src/components/SentryErrorBoundary.js'\nimport { Box, Text, useTheme } from '../../../ink.js'\nimport { useAppState } from '../../../state/AppState.js'\nimport {\n  filterToolProgressMessages,\n  type Tool,\n  type Tools,\n} from '../../../Tool.js'\nimport type {\n  NormalizedUserMessage,\n  ProgressMessage,\n} from '../../../types/message.js'\nimport {\n  deleteClassifierApproval,\n  getClassifierApproval,\n  getYoloClassifierApproval,\n} from '../../../utils/classifierApprovals.js'\nimport type { buildMessageLookups } from '../../../utils/messages.js'\nimport { MessageResponse } from '../../MessageResponse.js'\nimport { HookProgressMessage } from '../HookProgressMessage.js'\n\ntype Props = {\n  message: NormalizedUserMessage\n  lookups: ReturnType<typeof buildMessageLookups>\n  toolUseID: string\n  progressMessagesForMessage: ProgressMessage[]\n  style?: 'condensed'\n  tool?: Tool\n  tools: Tools\n  verbose: boolean\n  width: number | string\n  isTranscriptMode?: boolean\n}\n\nexport function UserToolSuccessMessage({\n  message,\n  lookups,\n  toolUseID,\n  progressMessagesForMessage,\n  style,\n  tool,\n  tools,\n  verbose,\n  width,\n  isTranscriptMode,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  // Hook stays inside feature() ternary so external builds don't pay a\n  // per-scrollback-message store subscription — same pattern as\n  // UserPromptMessage.tsx.\n  const isBriefOnly =\n    feature('KAIROS') || feature('KAIROS_BRIEF')\n      ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n        useAppState(s => s.isBriefOnly)\n      : false\n\n  // Capture classifier approval once on mount, then delete from Map to prevent linear growth.\n  // useState lazy initializer ensures the value persists across re-renders.\n  const [classifierRule] = React.useState(() =>\n    getClassifierApproval(toolUseID),\n  )\n  const [yoloReason] = React.useState(() =>\n    getYoloClassifierApproval(toolUseID),\n  )\n  React.useEffect(() => {\n    deleteClassifierApproval(toolUseID)\n  }, [toolUseID])\n\n  if (!message.toolUseResult || !tool) {\n    return null\n  }\n\n  // Resumed transcripts deserialize toolUseResult via raw JSON.parse with no\n  // validation (parseJSONL). A partial/corrupt/old-format result crashes\n  // renderToolResultMessage on first field access (anthropics/claude-code#39817).\n  // Validate against outputSchema before rendering — mirrors CollapsedReadSearchContent.\n  const parsedOutput = tool.outputSchema?.safeParse(message.toolUseResult)\n  if (parsedOutput && !parsedOutput.success) {\n    return null\n  }\n  const toolResult = parsedOutput?.data ?? message.toolUseResult\n\n  const renderedMessage =\n    tool.renderToolResultMessage?.(\n      toolResult as never,\n      filterToolProgressMessages(progressMessagesForMessage),\n      {\n        style,\n        theme,\n        tools,\n        verbose,\n        isTranscriptMode,\n        isBriefOnly,\n        input: lookups.toolUseByToolUseID.get(toolUseID)?.input,\n      },\n    ) ?? null\n\n  // Don't render anything if the tool result message is null\n  if (renderedMessage === null) {\n    return null\n  }\n\n  // Tools that return '' from userFacingName opt out of tool chrome and\n  // render like plain assistant text. Skip the tool-result width constraint\n  // so MarkdownTable's SAFETY_MARGIN=4 (tuned for the assistant-text 2-col\n  // dot gutter) holds — otherwise tables wrap their box-drawing chars.\n  const rendersAsAssistantText = tool.userFacingName(undefined) === ''\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box\n        flexDirection=\"column\"\n        width={rendersAsAssistantText ? undefined : width}\n      >\n        {renderedMessage}\n        {feature('BASH_CLASSIFIER')\n          ? classifierRule && (\n              <MessageResponse height={1}>\n                <Text dimColor>\n                  <Text color=\"success\">{figures.tick}</Text>\n                  {' Auto-approved \\u00b7 matched '}\n                  {`\"${classifierRule}\"`}\n                </Text>\n              </MessageResponse>\n            )\n          : null}\n        {feature('TRANSCRIPT_CLASSIFIER')\n          ? yoloReason && (\n              <MessageResponse height={1}>\n                <Text dimColor>Allowed by auto mode classifier</Text>\n              </MessageResponse>\n            )\n          : null}\n      </Box>\n      <SentryErrorBoundary>\n        <HookProgressMessage\n          hookEvent=\"PostToolUse\"\n          lookups={lookups}\n          toolUseID={toolUseID}\n          verbose={verbose}\n          isTranscriptMode={isTranscriptMode}\n        />\n      </SentryErrorBoundary>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/messages/UserToolResultMessage/utils.tsx

@@ -0,0 +1,44 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ToolUseBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import { useMemo } from 'react';
+import { findToolByName, type Tool, type Tools } from '../../../Tool.js';
+import type { buildMessageLookups } from '../../../utils/messages.js';
+export function useGetToolFromMessages(toolUseID, tools, lookups) {
+  const $ = _c(7);
+  let t0;
+  if ($[0] !== lookups.toolUseByToolUseID || $[1] !== toolUseID || $[2] !== tools) {
+    bb0: {
+      const toolUse = lookups.toolUseByToolUseID.get(toolUseID);
+      if (!toolUse) {
+        t0 = null;
+        break bb0;
+      }
+      const tool = findToolByName(tools, toolUse.name);
+      if (!tool) {
+        t0 = null;
+        break bb0;
+      }
+      let t1;
+      if ($[4] !== tool || $[5] !== toolUse) {
+        t1 = {
+          tool,
+          toolUse
+        };
+        $[4] = tool;
+        $[5] = toolUse;
+        $[6] = t1;
+      } else {
+        t1 = $[6];
+      }
+      t0 = t1;
+    }
+    $[0] = lookups.toolUseByToolUseID;
+    $[1] = toolUseID;
+    $[2] = tools;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/messages/nullRenderingAttachments.ts

@@ -0,0 +1,70 @@
+import type { Attachment } from 'src/utils/attachments.js'
+import type { Message, NormalizedMessage } from '../../types/message.js'
+
+/**
+ * Attachment types that AttachmentMessage renders as `null` unconditionally
+ * (no visible output regardless of runtime state). Messages.tsx filters these
+ * out BEFORE the render cap / message count so invisible entries don't consume
+ * the 200-message render budget (CC-724).
+ *
+ * Sync is enforced by TypeScript: AttachmentMessage's switch `default:` branch
+ * asserts `attachment.type satisfies NullRenderingAttachmentType`. Adding a new
+ * Attachment type without either a case or an entry here will fail typecheck.
+ */
+const NULL_RENDERING_TYPES = [
+  'hook_success',
+  'hook_additional_context',
+  'hook_cancelled',
+  'command_permissions',
+  'agent_mention',
+  'budget_usd',
+  'critical_system_reminder',
+  'edited_image_file',
+  'edited_text_file',
+  'opened_file_in_ide',
+  'output_style',
+  'plan_mode',
+  'plan_mode_exit',
+  'plan_mode_reentry',
+  'structured_output',
+  'team_context',
+  'todo_reminder',
+  'context_efficiency',
+  'deferred_tools_delta',
+  'mcp_instructions_delta',
+  'companion_intro',
+  'token_usage',
+  'ultrathink_effort',
+  'max_turns_reached',
+  'task_reminder',
+  'auto_mode',
+  'auto_mode_exit',
+  'output_token_usage',
+  'pen_mode_enter',
+  'pen_mode_exit',
+  'verify_plan_reminder',
+  'current_session_memory',
+  'compaction_reminder',
+  'date_change',
+] as const satisfies readonly Attachment['type'][]
+
+export type NullRenderingAttachmentType = (typeof NULL_RENDERING_TYPES)[number]
+
+const NULL_RENDERING_ATTACHMENT_TYPES: ReadonlySet<Attachment['type']> =
+  new Set(NULL_RENDERING_TYPES)
+
+/**
+ * True when this message is an attachment that AttachmentMessage renders as
+ * null with no visible output. Messages.tsx filters these out before counting
+ * and before applying the 200-message render cap, so invisible hook
+ * attachments (hook_success, hook_additional_context, hook_cancelled) don't
+ * inflate the "N messages" count or eat into the render budget (CC-724).
+ */
+export function isNullRenderingAttachment(
+  msg: Message | NormalizedMessage,
+): boolean {
+  return (
+    msg.type === 'attachment' &&
+    NULL_RENDERING_ATTACHMENT_TYPES.has(msg.attachment.type)
+  )
+}