ummaya 0.2.3 → 0.2.5

package/tui/src/tools/AskUserQuestionTool/AskUserQuestionTool.tsx

@@ -1,266 +1,238 @@
-import { c as _c } from "react/compiler-runtime";
-import { feature } from 'bun:bundle';
-import * as React from 'react';
-import { getAllowedChannels, getQuestionPreviewFormat } from 'src/bootstrap/state.js';
-import { MessageResponse } from 'src/components/MessageResponse.js';
-import { BLACK_CIRCLE } from 'src/constants/figures.js';
-import { getModeColor } from 'src/utils/permissions/PermissionMode.js';
-import { z } from 'zod/v4';
-import { Box, Text } from '../../ink.js';
-import type { Tool } from '../../Tool.js';
-import { buildTool, type ToolDef } from '../../Tool.js';
-import { lazySchema } from '../../utils/lazySchema.js';
-import { ASK_USER_QUESTION_TOOL_CHIP_WIDTH, ASK_USER_QUESTION_TOOL_NAME, ASK_USER_QUESTION_TOOL_PROMPT, DESCRIPTION, PREVIEW_FEATURE_PROMPT } from './prompt.js';
-const questionOptionSchema = lazySchema(() => z.object({
-  label: z.string().describe('The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.'),
-  description: z.string().describe('Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.'),
-  preview: z.string().optional().describe('Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format.')
-}));
-const questionSchema = lazySchema(() => z.object({
-  question: z.string().describe('The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?"'),
-  header: z.string().describe(`Very short label displayed as a chip/tag (max ${ASK_USER_QUESTION_TOOL_CHIP_WIDTH} chars). Examples: "Auth method", "Library", "Approach".`),
-  options: z.array(questionOptionSchema()).min(2).max(4).describe(`The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically.`),
-  multiSelect: z.boolean().default(false).describe('Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive.')
-}));
+import { feature } from 'bun:bundle'
+import * as React from 'react'
+import {
+  getAllowedChannels,
+  getQuestionPreviewFormat,
+} from 'src/bootstrap/state.js'
+import { MessageResponse } from 'src/components/MessageResponse.js'
+import { BLACK_CIRCLE } from 'src/constants/figures.js'
+import { getModeColor } from 'src/utils/permissions/PermissionMode.js'
+import { z } from 'zod/v4'
+import { Box, Text } from '../../ink.js'
+import { buildTool, type Tool, type ToolDef } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { buildAgentSupportMetadata } from '../AgentTool/orchestrationSupport.js'
+import {
+  ASK_USER_QUESTION_TOOL_CHIP_WIDTH,
+  ASK_USER_QUESTION_TOOL_NAME,
+  ASK_USER_QUESTION_TOOL_PROMPT,
+  DESCRIPTION,
+  PREVIEW_FEATURE_PROMPT,
+} from './prompt.js'
+
+const questionOptionSchema = lazySchema(() =>
+  z.object({
+    label: z.string().describe('The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.'),
+    description: z.string().describe('Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.'),
+    preview: z.string().optional().describe('Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format.'),
+  }),
+)
+
+const questionSchema = lazySchema(() =>
+  z.object({
+    question: z.string().describe('The complete question to ask the user. Should be clear, specific, and end with a question mark.'),
+    header: z.string().describe(`Very short label displayed as a chip/tag (max ${ASK_USER_QUESTION_TOOL_CHIP_WIDTH} chars).`),
+    options: z.array(questionOptionSchema()).min(2).max(4).describe('The available choices for this question. Must have 2-4 options.'),
+    multiSelect: z.boolean().default(false).describe('Set to true to allow the user to select multiple options instead of just one.'),
+  }),
+)
+
 const annotationsSchema = lazySchema(() => {
   const annotationSchema = z.object({
     preview: z.string().optional().describe('The preview content of the selected option, if the question used previews.'),
-    notes: z.string().optional().describe('Free-text notes the user added to their selection.')
-  });
-  return z.record(z.string(), annotationSchema).optional().describe('Optional per-question annotations from the user (e.g., notes on preview selections). Keyed by question text.');
-});
-const UNIQUENESS_REFINE = {
-  check: (data: {
-    questions: {
-      question: string;
-      options: {
-        label: string;
-      }[];
-    }[];
-  }) => {
-    const questions = data.questions.map(q => q.question);
-    if (questions.length !== new Set(questions).size) {
-      return false;
-    }
+    notes: z.string().optional().describe('Free-text notes the user added to their selection.'),
+  })
+  return z.record(z.string(), annotationSchema).optional()
+})
+
+const uniquenessRefine = {
+  check: (data: { questions: { question: string; options: { label: string }[] }[] }) => {
+    const questions = data.questions.map(q => q.question)
+    if (questions.length !== new Set(questions).size) return false
     for (const question of data.questions) {
-      const labels = question.options.map(opt => opt.label);
-      if (labels.length !== new Set(labels).size) {
-        return false;
-      }
+      const labels = question.options.map(option => option.label)
+      if (labels.length !== new Set(labels).size) return false
     }
-    return true;
+    return true
   },
-  message: 'Question texts must be unique, option labels must be unique within each question'
-} as const;
+  message:
+    'Question texts must be unique, option labels must be unique within each question',
+} as const
+
 const commonFields = lazySchema(() => ({
-  answers: z.record(z.string(), z.string()).optional().describe('User answers collected by the permission component'),
+  answers: z.record(z.string(), z.string()).optional(),
   annotations: annotationsSchema(),
-  metadata: z.object({
-    source: z.string().optional().describe('Optional identifier for the source of this question (e.g., "remember" for /remember command). Used for analytics tracking.')
-  }).optional().describe('Optional metadata for tracking and analytics purposes. Not displayed to user.')
-}));
-const inputSchema = lazySchema(() => z.strictObject({
-  questions: z.array(questionSchema()).min(1).max(4).describe('Questions to ask the user (1-4 questions)'),
-  ...commonFields()
-}).refine(UNIQUENESS_REFINE.check, {
-  message: UNIQUENESS_REFINE.message
-}));
-type InputSchema = ReturnType<typeof inputSchema>;
-const outputSchema = lazySchema(() => z.object({
-  questions: z.array(questionSchema()).describe('The questions that were asked'),
-  answers: z.record(z.string(), z.string()).describe('The answers provided by the user (question text -> answer string; multi-select answers are comma-separated)'),
-  annotations: annotationsSchema()
-}));
-type OutputSchema = ReturnType<typeof outputSchema>;
+  metadata: z.object({ source: z.string().optional() }).optional(),
+}))
+
+const inputSchema = lazySchema(() =>
+  z
+    .strictObject({
+      questions: z.array(questionSchema()).min(1).max(4),
+      ...commonFields(),
+    })
+    .refine(uniquenessRefine.check, { message: uniquenessRefine.message }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    questions: z.array(questionSchema()),
+    answers: z.record(z.string(), z.string()),
+    annotations: annotationsSchema(),
+    evidenceJoinKey: z.string(),
+    parentToolUseId: z.string(),
+    resumeToken: z.string(),
+    permissionFlow: z.literal('coordinator_parent_round_trip'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
 
-// SDK schemas are identical to internal schemas now that `preview` and
-// `annotations` are public (configurable via `toolConfig.askUserQuestion`).
-export const _sdkInputSchema = inputSchema;
-export const _sdkOutputSchema = outputSchema;
-export type Question = z.infer<ReturnType<typeof questionSchema>>;
-export type QuestionOption = z.infer<ReturnType<typeof questionOptionSchema>>;
-export type Output = z.infer<OutputSchema>;
-function AskUserQuestionResultMessage(t0) {
-  const $ = _c(3);
-  const {
-    answers
-  } = t0;
-  let t1;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = <Box flexDirection="row"><Text color={getModeColor("default")}>{BLACK_CIRCLE} </Text><Text>User answered UMMAYA's questions:</Text></Box>;
-    $[0] = t1;
-  } else {
-    t1 = $[0];
+export const _sdkInputSchema = inputSchema
+export const _sdkOutputSchema = outputSchema
+export type Question = z.infer<ReturnType<typeof questionSchema>>
+export type QuestionOption = z.infer<ReturnType<typeof questionOptionSchema>>
+export type Output = z.infer<OutputSchema>
+
+function AskUserQuestionResultMessage({
+  answers,
+}: {
+  readonly answers: Output['answers']
+}): React.ReactNode {
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Box flexDirection="row">
+        <Text color={getModeColor('default')}>{BLACK_CIRCLE}&nbsp;</Text>
+        <Text>User answered UMMAYA&apos;s questions:</Text>
+      </Box>
+      <MessageResponse>
+        <Box flexDirection="column">
+          {Object.entries(answers).map(([questionText, answer]) => (
+            <Text key={questionText} color="inactive">
+              · {questionText} → {answer}
+            </Text>
+          ))}
+        </Box>
+      </MessageResponse>
+    </Box>
+  )
+}
+
+function validateHtmlPreview(preview: string | undefined): string | null {
+  if (preview === undefined) return null
+  if (/<\s*(html|body|!doctype)\b/iu.test(preview)) {
+    return 'preview must be an HTML fragment, not a full document (no <html>, <body>, or <!DOCTYPE>)'
   }
-  let t2;
-  if ($[1] !== answers) {
-    t2 = <Box flexDirection="column" marginTop={1}>{t1}<MessageResponse><Box flexDirection="column">{Object.entries(answers).map(_temp)}</Box></MessageResponse></Box>;
-    $[1] = answers;
-    $[2] = t2;
-  } else {
-    t2 = $[2];
+  if (/<\s*(script|style)\b/iu.test(preview)) {
+    return 'preview must not contain <script> or <style> tags. Use inline styles via the style attribute if needed.'
   }
-  return t2;
-}
-function _temp(t0) {
-  const [questionText, answer] = t0;
-  return <Text key={questionText} color="inactive">· {questionText} → {answer}</Text>;
+  if (!/<[a-z][^>]*>/iu.test(preview)) {
+    return 'preview must contain HTML (previewFormat is set to "html"). Wrap content in a tag like <div> or <pre>.'
+  }
+  return null
 }
+
 export const AskUserQuestionTool: Tool<InputSchema, Output> = buildTool({
   name: ASK_USER_QUESTION_TOOL_NAME,
   searchHint: 'prompt the user with a multiple-choice question',
   maxResultSizeChars: 100_000,
   shouldDefer: true,
   async description() {
-    return DESCRIPTION;
+    return DESCRIPTION
   },
   async prompt() {
-    const format = getQuestionPreviewFormat();
-    if (format === undefined) {
-      // SDK consumer that hasn't opted into a preview format — omit preview
-      // guidance (they may not render the field at all).
-      return ASK_USER_QUESTION_TOOL_PROMPT;
-    }
-    return ASK_USER_QUESTION_TOOL_PROMPT + PREVIEW_FEATURE_PROMPT[format];
+    const format = getQuestionPreviewFormat()
+    return format === undefined
+      ? ASK_USER_QUESTION_TOOL_PROMPT
+      : ASK_USER_QUESTION_TOOL_PROMPT + PREVIEW_FEATURE_PROMPT[format]
   },
   get inputSchema(): InputSchema {
-    return inputSchema();
+    return inputSchema()
   },
   get outputSchema(): OutputSchema {
-    return outputSchema();
+    return outputSchema()
   },
   userFacingName() {
-    return '';
+    return ''
   },
   isEnabled() {
-    // When --channels is active the user is likely on Telegram/Discord, not
-    // watching the TUI. The multiple-choice dialog would hang with nobody at
-    // the keyboard. Channel permission relay already skips
-    // requiresUserInteraction() tools (interactiveHandler.ts) so there's
-    // no alternate approval path.
     if ((feature('KAIROS') || feature('KAIROS_CHANNELS')) && getAllowedChannels().length > 0) {
-      return false;
+      return false
     }
-    return true;
+    return true
   },
   isConcurrencySafe() {
-    return true;
+    return true
   },
   isReadOnly() {
-    return true;
+    return true
   },
   toAutoClassifierInput(input) {
-    return input.questions.map(q => q.question).join(' | ');
+    return input.questions.map(question => question.question).join(' | ')
   },
   requiresUserInteraction() {
-    return true;
-  },
-  async validateInput({
-    questions
-  }) {
-    if (getQuestionPreviewFormat() !== 'html') {
-      return {
-        result: true
-      };
-    }
-    for (const q of questions) {
-      for (const opt of q.options) {
-        const err = validateHtmlPreview(opt.preview);
-        if (err) {
+    return true
+  },
+  async validateInput({ questions }) {
+    if (getQuestionPreviewFormat() !== 'html') return { result: true }
+    for (const question of questions) {
+      for (const option of question.options) {
+        const error = validateHtmlPreview(option.preview)
+        if (error) {
           return {
             result: false,
-            message: `Option "${opt.label}" in question "${q.question}": ${err}`,
-            errorCode: 1
-          };
+            message: `Option "${option.label}" in question "${question.question}": ${error}`,
+            errorCode: 1,
+          }
         }
       }
     }
-    return {
-      result: true
-    };
+    return { result: true }
   },
   async checkPermissions(input) {
-    return {
-      behavior: 'ask' as const,
-      message: 'Answer questions?',
-      updatedInput: input
-    };
+    return { behavior: 'ask', message: 'Answer questions?', updatedInput: input }
   },
   renderToolUseMessage() {
-    return null;
+    return null
   },
   renderToolUseProgressMessage() {
-    return null;
+    return null
   },
-  renderToolResultMessage({
-    answers
-  }, _toolUseID) {
-    return <AskUserQuestionResultMessage answers={answers} />;
+  renderToolResultMessage({ answers }) {
+    return <AskUserQuestionResultMessage answers={answers} />
   },
   renderToolUseRejectedMessage() {
-    return <Box flexDirection="row" marginTop={1}>
+    return (
+      <Box flexDirection="row" marginTop={1}>
         <Text color={getModeColor('default')}>{BLACK_CIRCLE}&nbsp;</Text>
         <Text>User declined to answer questions</Text>
-      </Box>;
+      </Box>
+    )
   },
   renderToolUseErrorMessage() {
-    return null;
+    return null
   },
-  async call({
-    questions,
-    answers = {},
-    annotations
-  }, _context) {
+  async call({ questions, answers = {}, annotations }, context) {
     return {
       data: {
         questions,
         answers,
-        ...(annotations && {
-          annotations
-        })
-      }
-    };
+        ...(annotations && { annotations }),
+        ...buildAgentSupportMetadata({
+          taskId: ASK_USER_QUESTION_TOOL_NAME,
+          parentToolUseId: context.toolUseId,
+        }),
+      },
+    }
   },
-  mapToolResultToToolResultBlockParam({
-    answers,
-    annotations
-  }, toolUseID) {
-    const answersText = Object.entries(answers).map(([questionText, answer]) => {
-      const annotation = annotations?.[questionText];
-      const parts = [`"${questionText}"="${answer}"`];
-      if (annotation?.preview) {
-        parts.push(`selected preview:\n${annotation.preview}`);
-      }
-      if (annotation?.notes) {
-        parts.push(`user notes: ${annotation.notes}`);
-      }
-      return parts.join(' ');
-    }).join(', ');
+  mapToolResultToToolResultBlockParam(result, toolUseID) {
+    const answersText = Object.entries(result.answers)
+      .map(([questionText, answer]) => `"${questionText}"="${answer}"`)
+      .join(', ')
     return {
       type: 'tool_result',
-      content: `User has answered your questions: ${answersText}. You can now continue with the user's answers in mind.`,
-      tool_use_id: toolUseID
-    };
-  }
-} satisfies ToolDef<InputSchema, Output>);
-
-// Lightweight HTML fragment check. Not a parser — HTML5 parsers are
-// error-recovering by spec and accept anything. We're checking model intent
-// (did it emit HTML?) and catching the specific things we told it not to do.
-function validateHtmlPreview(preview: string | undefined): string | null {
-  if (preview === undefined) return null;
-  if (/<\s*(html|body|!doctype)\b/i.test(preview)) {
-    return 'preview must be an HTML fragment, not a full document (no <html>, <body>, or <!DOCTYPE>)';
-  }
-  // SDK consumers typically set this via innerHTML — disallow executable/style
-  // tags so a preview can't run code or restyle the host page. Inline event
-  // handlers (onclick etc.) are still possible; consumers should sanitize.
-  if (/<\s*(script|style)\b/i.test(preview)) {
-    return 'preview must not contain <script> or <style> tags. Use inline styles via the style attribute if needed.';
-  }
-  if (!/<[a-z][^>]*>/i.test(preview)) {
-    return 'preview must contain HTML (previewFormat is set to "html"). Wrap content in a tag like <div> or <pre>.';
-  }
-  return null;
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","getAllowedChannels","getQuestionPreviewFormat","MessageResponse","BLACK_CIRCLE","getModeColor","z","Box","Text","Tool","buildTool","ToolDef","lazySchema","ASK_USER_QUESTION_TOOL_CHIP_WIDTH","ASK_USER_QUESTION_TOOL_NAME","ASK_USER_QUESTION_TOOL_PROMPT","DESCRIPTION","PREVIEW_FEATURE_PROMPT","questionOptionSchema","object","label","string","describe","description","preview","optional","questionSchema","question","header","options","array","min","max","multiSelect","boolean","default","annotationsSchema","annotationSchema","notes","record","UNIQUENESS_REFINE","check","data","questions","map","q","length","Set","size","labels","opt","message","const","commonFields","answers","annotations","metadata","source","inputSchema","strictObject","refine","InputSchema","ReturnType","outputSchema","OutputSchema","_sdkInputSchema","_sdkOutputSchema","Question","infer","QuestionOption","Output","AskUserQuestionResultMessage","t0","$","_c","t1","Symbol","for","t2","Object","entries","_temp","questionText","answer","AskUserQuestionTool","name","searchHint","maxResultSizeChars","shouldDefer","prompt","format","undefined","userFacingName","isEnabled","isConcurrencySafe","isReadOnly","toAutoClassifierInput","input","join","requiresUserInteraction","validateInput","result","err","validateHtmlPreview","errorCode","checkPermissions","behavior","updatedInput","renderToolUseMessage","renderToolUseProgressMessage","renderToolResultMessage","_toolUseID","renderToolUseRejectedMessage","renderToolUseErrorMessage","call","_context","mapToolResultToToolResultBlockParam","toolUseID","answersText","annotation","parts","push","type","content","tool_use_id","test"],"sources":["AskUserQuestionTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport {\n  getAllowedChannels,\n  getQuestionPreviewFormat,\n} from 'src/bootstrap/state.js'\nimport { MessageResponse } from 'src/components/MessageResponse.js'\nimport { BLACK_CIRCLE } from 'src/constants/figures.js'\nimport { getModeColor } from 'src/utils/permissions/PermissionMode.js'\nimport { z } from 'zod/v4'\nimport { Box, Text } from '../../ink.js'\nimport type { Tool } from '../../Tool.js'\nimport { buildTool, type ToolDef } from '../../Tool.js'\nimport { lazySchema } from '../../utils/lazySchema.js'\nimport {\n  ASK_USER_QUESTION_TOOL_CHIP_WIDTH,\n  ASK_USER_QUESTION_TOOL_NAME,\n  ASK_USER_QUESTION_TOOL_PROMPT,\n  DESCRIPTION,\n  PREVIEW_FEATURE_PROMPT,\n} from './prompt.js'\n\nconst questionOptionSchema = lazySchema(() =>\n  z.object({\n    label: z\n      .string()\n      .describe(\n        'The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.',\n      ),\n    description: z\n      .string()\n      .describe(\n        'Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.',\n      ),\n    preview: z\n      .string()\n      .optional()\n      .describe(\n        'Optional preview content rendered when this option is focused. Use for mockups, code snippets, or visual comparisons that help users compare options. See the tool description for the expected content format.',\n      ),\n  }),\n)\n\nconst questionSchema = lazySchema(() =>\n  z.object({\n    question: z\n      .string()\n      .describe(\n        'The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: \"Which library should we use for date formatting?\" If multiSelect is true, phrase it accordingly, e.g. \"Which features do you want to enable?\"',\n      ),\n    header: z\n      .string()\n      .describe(\n        `Very short label displayed as a chip/tag (max ${ASK_USER_QUESTION_TOOL_CHIP_WIDTH} chars). Examples: \"Auth method\", \"Library\", \"Approach\".`,\n      ),\n    options: z\n      .array(questionOptionSchema())\n      .min(2)\n      .max(4)\n      .describe(\n        `The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically.`,\n      ),\n    multiSelect: z\n      .boolean()\n      .default(false)\n      .describe(\n        'Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive.',\n      ),\n  }),\n)\n\nconst annotationsSchema = lazySchema(() => {\n  const annotationSchema = z.object({\n    preview: z\n      .string()\n      .optional()\n      .describe(\n        'The preview content of the selected option, if the question used previews.',\n      ),\n    notes: z\n      .string()\n      .optional()\n      .describe('Free-text notes the user added to their selection.'),\n  })\n\n  return z\n    .record(z.string(), annotationSchema)\n    .optional()\n    .describe(\n      'Optional per-question annotations from the user (e.g., notes on preview selections). Keyed by question text.',\n    )\n})\n\nconst UNIQUENESS_REFINE = {\n  check: (data: {\n    questions: { question: string; options: { label: string }[] }[]\n  }) => {\n    const questions = data.questions.map(q => q.question)\n    if (questions.length !== new Set(questions).size) {\n      return false\n    }\n    for (const question of data.questions) {\n      const labels = question.options.map(opt => opt.label)\n      if (labels.length !== new Set(labels).size) {\n        return false\n      }\n    }\n    return true\n  },\n  message:\n    'Question texts must be unique, option labels must be unique within each question',\n} as const\n\nconst commonFields = lazySchema(() => ({\n  answers: z\n    .record(z.string(), z.string())\n    .optional()\n    .describe('User answers collected by the permission component'),\n  annotations: annotationsSchema(),\n  metadata: z\n    .object({\n      source: z\n        .string()\n        .optional()\n        .describe(\n          'Optional identifier for the source of this question (e.g., \"remember\" for /remember command). Used for analytics tracking.',\n        ),\n    })\n    .optional()\n    .describe(\n      'Optional metadata for tracking and analytics purposes. Not displayed to user.',\n    ),\n}))\n\nconst inputSchema = lazySchema(() =>\n  z\n    .strictObject({\n      questions: z\n        .array(questionSchema())\n        .min(1)\n        .max(4)\n        .describe('Questions to ask the user (1-4 questions)'),\n      ...commonFields(),\n    })\n    .refine(UNIQUENESS_REFINE.check, {\n      message: UNIQUENESS_REFINE.message,\n    }),\n)\ntype InputSchema = ReturnType<typeof inputSchema>\n\nconst outputSchema = lazySchema(() =>\n  z.object({\n    questions: z\n      .array(questionSchema())\n      .describe('The questions that were asked'),\n    answers: z\n      .record(z.string(), z.string())\n      .describe(\n        'The answers provided by the user (question text -> answer string; multi-select answers are comma-separated)',\n      ),\n    annotations: annotationsSchema(),\n  }),\n)\ntype OutputSchema = ReturnType<typeof outputSchema>\n\n// SDK schemas are identical to internal schemas now that `preview` and\n// `annotations` are public (configurable via `toolConfig.askUserQuestion`).\nexport const _sdkInputSchema = inputSchema\nexport const _sdkOutputSchema = outputSchema\n\nexport type Question = z.infer<ReturnType<typeof questionSchema>>\nexport type QuestionOption = z.infer<ReturnType<typeof questionOptionSchema>>\nexport type Output = z.infer<OutputSchema>\n\nfunction AskUserQuestionResultMessage({\n  answers,\n}: {\n  answers: Output['answers']\n}): React.ReactNode {\n  return (\n    <Box flexDirection=\"column\" marginTop={1}>\n      <Box flexDirection=\"row\">\n        <Text color={getModeColor('default')}>{BLACK_CIRCLE}&nbsp;</Text>\n        <Text>User answered Claude&apos;s questions:</Text>\n      </Box>\n      <MessageResponse>\n        <Box flexDirection=\"column\">\n          {Object.entries(answers).map(([questionText, answer]) => (\n            <Text key={questionText} color=\"inactive\">\n              · {questionText} → {answer}\n            </Text>\n          ))}\n        </Box>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nexport const AskUserQuestionTool: Tool<InputSchema, Output> = buildTool({\n  name: ASK_USER_QUESTION_TOOL_NAME,\n  searchHint: 'prompt the user with a multiple-choice question',\n  maxResultSizeChars: 100_000,\n  shouldDefer: true,\n  async description() {\n    return DESCRIPTION\n  },\n  async prompt() {\n    const format = getQuestionPreviewFormat()\n    if (format === undefined) {\n      // SDK consumer that hasn't opted into a preview format — omit preview\n      // guidance (they may not render the field at all).\n      return ASK_USER_QUESTION_TOOL_PROMPT\n    }\n    return ASK_USER_QUESTION_TOOL_PROMPT + PREVIEW_FEATURE_PROMPT[format]\n  },\n  get inputSchema(): InputSchema {\n    return inputSchema()\n  },\n  get outputSchema(): OutputSchema {\n    return outputSchema()\n  },\n  userFacingName() {\n    return ''\n  },\n  isEnabled() {\n    // When --channels is active the user is likely on Telegram/Discord, not\n    // watching the TUI. The multiple-choice dialog would hang with nobody at\n    // the keyboard. Channel permission relay already skips\n    // requiresUserInteraction() tools (interactiveHandler.ts) so there's\n    // no alternate approval path.\n    if (\n      (feature('KAIROS') || feature('KAIROS_CHANNELS')) &&\n      getAllowedChannels().length > 0\n    ) {\n      return false\n    }\n    return true\n  },\n  isConcurrencySafe() {\n    return true\n  },\n  isReadOnly() {\n    return true\n  },\n  toAutoClassifierInput(input) {\n    return input.questions.map(q => q.question).join(' | ')\n  },\n  requiresUserInteraction() {\n    return true\n  },\n  async validateInput({ questions }) {\n    if (getQuestionPreviewFormat() !== 'html') {\n      return { result: true }\n    }\n    for (const q of questions) {\n      for (const opt of q.options) {\n        const err = validateHtmlPreview(opt.preview)\n        if (err) {\n          return {\n            result: false,\n            message: `Option \"${opt.label}\" in question \"${q.question}\": ${err}`,\n            errorCode: 1,\n          }\n        }\n      }\n    }\n    return { result: true }\n  },\n  async checkPermissions(input) {\n    return {\n      behavior: 'ask' as const,\n      message: 'Answer questions?',\n      updatedInput: input,\n    }\n  },\n  renderToolUseMessage() {\n    return null\n  },\n  renderToolUseProgressMessage() {\n    return null\n  },\n  renderToolResultMessage({ answers }, _toolUseID) {\n    return <AskUserQuestionResultMessage answers={answers} />\n  },\n  renderToolUseRejectedMessage() {\n    return (\n      <Box flexDirection=\"row\" marginTop={1}>\n        <Text color={getModeColor('default')}>{BLACK_CIRCLE}&nbsp;</Text>\n        <Text>User declined to answer questions</Text>\n      </Box>\n    )\n  },\n  renderToolUseErrorMessage() {\n    return null\n  },\n  async call({ questions, answers = {}, annotations }, _context) {\n    return {\n      data: { questions, answers, ...(annotations && { annotations }) },\n    }\n  },\n  mapToolResultToToolResultBlockParam({ answers, annotations }, toolUseID) {\n    const answersText = Object.entries(answers)\n      .map(([questionText, answer]) => {\n        const annotation = annotations?.[questionText]\n        const parts = [`\"${questionText}\"=\"${answer}\"`]\n        if (annotation?.preview) {\n          parts.push(`selected preview:\\n${annotation.preview}`)\n        }\n        if (annotation?.notes) {\n          parts.push(`user notes: ${annotation.notes}`)\n        }\n        return parts.join(' ')\n      })\n      .join(', ')\n\n    return {\n      type: 'tool_result',\n      content: `User has answered your questions: ${answersText}. You can now continue with the user's answers in mind.`,\n      tool_use_id: toolUseID,\n    }\n  },\n} satisfies ToolDef<InputSchema, Output>)\n\n// Lightweight HTML fragment check. Not a parser — HTML5 parsers are\n// error-recovering by spec and accept anything. We're checking model intent\n// (did it emit HTML?) and catching the specific things we told it not to do.\nfunction validateHtmlPreview(preview: string | undefined): string | null {\n  if (preview === undefined) return null\n  if (/<\\s*(html|body|!doctype)\\b/i.test(preview)) {\n    return 'preview must be an HTML fragment, not a full document (no <html>, <body>, or <!DOCTYPE>)'\n  }\n  // SDK consumers typically set this via innerHTML — disallow executable/style\n  // tags so a preview can't run code or restyle the host page. Inline event\n  // handlers (onclick etc.) are still possible; consumers should sanitize.\n  if (/<\\s*(script|style)\\b/i.test(preview)) {\n    return 'preview must not contain <script> or <style> tags. Use inline styles via the style attribute if needed.'\n  }\n  if (!/<[a-z][^>]*>/i.test(preview)) {\n    return 'preview must contain HTML (previewFormat is set to \"html\"). Wrap content in a tag like <div> or <pre>.'\n  }\n  return null\n}\n"],"mappings":"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","ignoreList":[]}
+      content: `User has answered your questions: ${answersText}. You can now continue with the user's answers in mind.\n\nevidence_join_key: ${result.evidenceJoinKey}\nparent_tool_use_id: ${result.parentToolUseId}\nresume_token: ${result.resumeToken}\npermission_flow: ${result.permissionFlow}`,
+      tool_use_id: toolUseID,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)