@cuongtran001/kanna 0.39.2

package/src/shared/tools.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, test } from "bun:test"
+import { hydrateToolResult, normalizeToolCall } from "./tools"
+
+describe("normalizeToolCall", () => {
+  test("maps AskUserQuestion input to typed questions", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: {
+        questions: [
+          {
+            question: "Which runtime?",
+            header: "Runtime",
+            options: [{ label: "Codex", description: "Use Codex" }],
+          },
+        ],
+      },
+    })
+
+    expect(tool.toolKind).toBe("ask_user_question")
+    if (tool.toolKind !== "ask_user_question") throw new Error("unexpected tool kind")
+    expect(tool.input.questions[0]?.question).toBe("Which runtime?")
+  })
+
+  test("maps Bash snake_case input to camelCase", () => {
+    const tool = normalizeToolCall({
+      toolName: "Bash",
+      toolId: "tool-2",
+      input: {
+        command: "pwd",
+        timeout: 5000,
+        run_in_background: true,
+      },
+    })
+
+    expect(tool.toolKind).toBe("bash")
+    if (tool.toolKind !== "bash") throw new Error("unexpected tool kind")
+    expect(tool.input.timeoutMs).toBe(5000)
+    expect(tool.input.runInBackground).toBe(true)
+  })
+
+  test("maps unknown MCP tools to mcp_generic", () => {
+    const tool = normalizeToolCall({
+      toolName: "mcp__sentry__search_issues",
+      toolId: "tool-3",
+      input: { query: "regression" },
+    })
+
+    expect(tool.toolKind).toBe("mcp_generic")
+    if (tool.toolKind !== "mcp_generic") throw new Error("unexpected tool kind")
+    expect(tool.input.server).toBe("sentry")
+    expect(tool.input.tool).toBe("search_issues")
+  })
+})
+
+describe("hydrateToolResult", () => {
+  test("hydrates AskUserQuestion answers", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: { questions: [] },
+    })
+
+    const result = hydrateToolResult(tool, JSON.stringify({ answers: { runtime: "codex" } }))
+    expect(result).toEqual({ answers: { runtime: ["codex"] } })
+  })
+
+  test("hydrates AskUserQuestion multi-select answers", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: { questions: [] },
+    })
+
+    const result = hydrateToolResult(tool, JSON.stringify({ answers: { runtime: ["bun", "node"] } }))
+    expect(result).toEqual({ answers: { runtime: ["bun", "node"] } })
+  })
+
+  test("hydrates ExitPlanMode decisions", () => {
+    const tool = normalizeToolCall({
+      toolName: "ExitPlanMode",
+      toolId: "tool-2",
+      input: { plan: "Do the thing" },
+    })
+
+    const result = hydrateToolResult(tool, { confirmed: true, clearContext: true })
+    expect(result).toEqual({ confirmed: true, clearContext: true, message: undefined })
+  })
+
+  test("hydrates Read file text results", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-3",
+      input: { file_path: "/tmp/example.ts" },
+    })
+
+    expect(hydrateToolResult(tool, "line 1\nline 2")).toBe("line 1\nline 2")
+  })
+
+  test("hydrates read image results with canonical image blocks intact", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-image",
+      input: { file_path: "/tmp/example.png" },
+    })
+
+    expect(hydrateToolResult(tool, {
+      content: [
+        {
+          type: "text",
+          text: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+        },
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })).toEqual({
+      content: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+      blocks: [
+        {
+          type: "text",
+          text: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+        },
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })
+  })
+
+  test("hydrates Claude read image results with source.base64 into canonical image blocks", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-image-claude",
+      input: { file_path: "/tmp/example.png" },
+    })
+
+    expect(hydrateToolResult(tool, {
+      content: [
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            data: "ZmFrZS1pbWFnZS1kYXRh",
+            media_type: "image/png",
+          },
+        },
+      ],
+    })).toEqual({
+      content: "",
+      blocks: [
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })
+  })
+})

package/src/shared/tools.ts

@@ -0,0 +1,327 @@
+import type {
+  AskUserQuestionItem,
+  AskUserQuestionAnswerMap,
+  AskUserQuestionToolResult,
+  ExitPlanModeToolResult,
+  HydratedToolCall,
+  NormalizedToolCall,
+  ReadFileToolResult,
+  TodoItem,
+} from "./types"
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+export function normalizeToolCall(args: {
+  toolName: string
+  toolId: string
+  input: Record<string, unknown>
+}): NormalizedToolCall {
+  const { toolName, toolId, input } = args
+
+  switch (toolName) {
+    case "AskUserQuestion":
+      return {
+        kind: "tool",
+        toolKind: "ask_user_question",
+        toolName,
+        toolId,
+        input: {
+          questions: Array.isArray(input.questions) ? (input.questions as AskUserQuestionItem[]) : [],
+        },
+        rawInput: input,
+      }
+    case "ExitPlanMode":
+      return {
+        kind: "tool",
+        toolKind: "exit_plan_mode",
+        toolName,
+        toolId,
+        input: {
+          plan: typeof input.plan === "string" ? input.plan : undefined,
+          summary: typeof input.summary === "string" ? input.summary : undefined,
+        },
+        rawInput: input,
+      }
+    case "TodoWrite":
+      return {
+        kind: "tool",
+        toolKind: "todo_write",
+        toolName,
+        toolId,
+        input: {
+          todos: Array.isArray(input.todos) ? (input.todos as TodoItem[]) : [],
+        },
+        rawInput: input,
+      }
+    case "Skill":
+      return {
+        kind: "tool",
+        toolKind: "skill",
+        toolName,
+        toolId,
+        input: {
+          skill: typeof input.skill === "string" ? input.skill : "",
+        },
+        rawInput: input,
+      }
+    case "Glob":
+      return {
+        kind: "tool",
+        toolKind: "glob",
+        toolName,
+        toolId,
+        input: {
+          pattern: typeof input.pattern === "string" ? input.pattern : "",
+        },
+        rawInput: input,
+      }
+    case "Grep":
+      return {
+        kind: "tool",
+        toolKind: "grep",
+        toolName,
+        toolId,
+        input: {
+          pattern: typeof input.pattern === "string" ? input.pattern : "",
+          outputMode: typeof input.output_mode === "string" ? input.output_mode : undefined,
+        },
+        rawInput: input,
+      }
+    case "Bash":
+      return {
+        kind: "tool",
+        toolKind: "bash",
+        toolName,
+        toolId,
+        input: {
+          command: typeof input.command === "string" ? input.command : "",
+          description: typeof input.description === "string" ? input.description : undefined,
+          timeoutMs: typeof input.timeout === "number" ? input.timeout : undefined,
+          runInBackground: Boolean(input.run_in_background),
+        },
+        rawInput: input,
+      }
+    case "WebSearch":
+      return {
+        kind: "tool",
+        toolKind: "web_search",
+        toolName,
+        toolId,
+        input: {
+          query: typeof input.query === "string" ? input.query : "",
+        },
+        rawInput: input,
+      }
+    case "Read":
+      return {
+        kind: "tool",
+        toolKind: "read_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+        },
+        rawInput: input,
+      }
+    case "Write":
+      return {
+        kind: "tool",
+        toolKind: "write_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+          content: typeof input.content === "string" ? input.content : "",
+        },
+        rawInput: input,
+      }
+    case "Edit":
+      return {
+        kind: "tool",
+        toolKind: "edit_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+          oldString: typeof input.old_string === "string" ? input.old_string : "",
+          newString: typeof input.new_string === "string" ? input.new_string : "",
+        },
+        rawInput: input,
+      }
+  }
+
+  const mcpMatch = toolName.match(/^mcp__(.+?)__(.+)$/)
+  if (mcpMatch) {
+    return {
+      kind: "tool",
+      toolKind: "mcp_generic",
+      toolName,
+      toolId,
+      input: {
+        server: mcpMatch[1],
+        tool: mcpMatch[2],
+        payload: input,
+      },
+      rawInput: input,
+    }
+  }
+
+  if (typeof input.subagent_type === "string") {
+    return {
+      kind: "tool",
+      toolKind: "subagent_task",
+      toolName,
+      toolId,
+      input: {
+        subagentType: input.subagent_type,
+      },
+      rawInput: input,
+    }
+  }
+
+  return {
+    kind: "tool",
+    toolKind: "unknown_tool",
+    toolName,
+    toolId,
+    input: {
+      payload: input,
+    },
+    rawInput: input,
+  }
+}
+
+function parseJsonValue(value: unknown): unknown {
+  if (typeof value !== "string") return value
+  try {
+    return JSON.parse(value)
+  } catch {
+    return value
+  }
+}
+
+type ReadStructuredTextBlock = {
+  type: "text"
+  text: string
+}
+
+type ReadStructuredImageBlock = {
+  type: "image"
+  data: string
+  mimeType?: string
+}
+
+function normalizeReadBlocks(value: unknown): Array<ReadStructuredTextBlock | ReadStructuredImageBlock> {
+  const blocks = (
+    value
+    && typeof value === "object"
+    && "content" in value
+    && Array.isArray((value as { content?: unknown }).content)
+  )
+    ? (value as { content: unknown[] }).content
+    : Array.isArray(value)
+      ? value
+      : []
+
+  const normalized: Array<ReadStructuredTextBlock | ReadStructuredImageBlock> = []
+
+  for (const block of blocks) {
+    if (!block || typeof block !== "object" || !("type" in block)) {
+      continue
+    }
+
+    if (block.type === "text" && typeof block.text === "string") {
+      normalized.push({ type: "text", text: block.text })
+      continue
+    }
+
+    if (block.type === "image") {
+      if ("data" in block && typeof block.data === "string") {
+        normalized.push({
+          type: "image",
+          data: block.data,
+          mimeType: typeof block.mimeType === "string" ? block.mimeType : undefined,
+        })
+        continue
+      }
+
+      if (
+        "source" in block
+        && block.source
+        && typeof block.source === "object"
+        && "type" in block.source
+        && block.source.type === "base64"
+        && "data" in block.source
+        && typeof block.source.data === "string"
+      ) {
+        normalized.push({
+          type: "image",
+          data: block.source.data,
+          mimeType: typeof block.source.media_type === "string" ? block.source.media_type : undefined,
+        })
+      }
+    }
+  }
+
+  return normalized
+}
+
+export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): HydratedToolCall["result"] {
+  const parsed = parseJsonValue(raw)
+
+  switch (tool.toolKind) {
+    case "ask_user_question": {
+      const record = asRecord(parsed)
+      const answers = asRecord(record?.answers) ?? (record ? record : {})
+      return {
+        answers: Object.fromEntries(
+          Object.entries(answers).map(([key, value]) => {
+            if (Array.isArray(value)) {
+              return [key, value.map((entry) => String(entry))]
+            }
+            if (value && typeof value === "object" && Array.isArray((value as { answers?: unknown }).answers)) {
+              return [key, (value as { answers: unknown[] }).answers.map((entry) => String(entry))]
+            }
+            if (value == null || value === "") {
+              return [key, []]
+            }
+            return [key, [String(value)]]
+          })
+        ) as AskUserQuestionAnswerMap,
+        ...(record?.discarded === true ? { discarded: true } : {}),
+      } satisfies AskUserQuestionToolResult
+    }
+    case "exit_plan_mode": {
+      const record = asRecord(parsed)
+      return {
+        confirmed: typeof record?.confirmed === "boolean" ? record.confirmed : undefined,
+        clearContext: typeof record?.clearContext === "boolean" ? record.clearContext : undefined,
+        message: typeof record?.message === "string" ? record.message : undefined,
+        ...(record?.discarded === true ? { discarded: true } : {}),
+      } satisfies ExitPlanModeToolResult
+    }
+    case "read_file":
+      if (typeof parsed === "string") {
+        return parsed
+      }
+      const blocks = normalizeReadBlocks(parsed)
+      if (blocks.length > 0) {
+        return {
+          content: blocks
+            .flatMap((block) => block.type === "text" ? [block.text] : [])
+            .join(""),
+          blocks,
+        } satisfies ReadFileToolResult
+      }
+
+      const record = asRecord(parsed)
+      return {
+        content: typeof record?.content === "string" ? record.content : JSON.stringify(parsed, null, 2),
+      } satisfies ReadFileToolResult
+    default:
+      return parsed
+  }
+}

package/src/shared/types.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test"
+import {
+  normalizeClaudeModelId,
+  normalizeCodexModelId,
+  supportsClaudeMaxReasoningEffort,
+} from "./types"
+
+describe("shared model normalization", () => {
+  test("normalizes Claude aliases via the provider catalog", () => {
+    expect(normalizeClaudeModelId("opus")).toBe("claude-opus-4-7")
+    expect(normalizeClaudeModelId("sonnet")).toBe("claude-sonnet-4-6")
+    expect(normalizeClaudeModelId("haiku")).toBe("claude-haiku-4-5-20251001")
+  })
+
+  test("normalizes legacy Codex aliases and defaults to the latest catalog model", () => {
+    expect(normalizeCodexModelId()).toBe("gpt-5.5")
+    expect(normalizeCodexModelId("gpt-5-codex")).toBe("gpt-5.3-codex")
+  })
+
+  test("uses declarative metadata for Claude max-effort support", () => {
+    expect(supportsClaudeMaxReasoningEffort("claude-opus-4-7")).toBe(true)
+    expect(supportsClaudeMaxReasoningEffort("opus")).toBe(true)
+    expect(supportsClaudeMaxReasoningEffort("claude-sonnet-4-6")).toBe(false)
+  })
+})