airaknit 1.1.2-rc.9

package/src/shared/tools.ts

@@ -0,0 +1,397 @@
+export const KANNA_MCP_SERVER_NAME = "tinkaria-mcp"
+
+import type {
+  AskUserQuestionItem,
+  AskUserQuestionAnswerMap,
+  AskUserQuestionToolResult,
+  ExitPlanModeToolResult,
+  HydratedToolCall,
+  ImageContentBlock,
+  NormalizedToolCall,
+  PresentContentInput,
+  PresentContentErrorToolResult,
+  PresentContentSchemaValidationError,
+  PresentContentValidationIssue,
+  PresentContentToolResult,
+  ReadFileImageResult,
+  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>
+}
+
+function isPresentContentKind(value: unknown): value is PresentContentInput["kind"] {
+  return value === "markdown" || value === "code" || value === "diagram"
+}
+
+function isPresentContentValidationIssue(value: unknown): value is PresentContentValidationIssue {
+  return Boolean(value)
+    && typeof value === "object"
+    && Array.isArray((value as { path?: unknown }).path)
+    && ((value as { path?: unknown[] }).path?.every((segment) => typeof segment === "string") ?? false)
+    && typeof (value as { code?: unknown }).code === "string"
+    && typeof (value as { message?: unknown }).message === "string"
+}
+
+function isPresentContentSchemaValidationError(value: unknown): value is PresentContentSchemaValidationError {
+  return Boolean(value)
+    && typeof value === "object"
+    && (value as { source?: unknown }).source === "schema_validation"
+    && (value as { schema?: unknown }).schema === "present_content"
+    && Array.isArray((value as { issues?: unknown }).issues)
+    && ((value as { issues?: unknown[] }).issues?.every(isPresentContentValidationIssue) ?? false)
+}
+
+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 "present_content":
+      return {
+        kind: "tool",
+        toolKind: "present_content",
+        toolName,
+        toolId,
+        input: {
+          title: typeof input.title === "string" ? input.title : "",
+          kind: isPresentContentKind(input.kind) ? input.kind : "markdown",
+          format: typeof input.format === "string" ? input.format : "text",
+          source: typeof input.source === "string" ? input.source : "",
+          summary: typeof input.summary === "string" ? input.summary : undefined,
+          collapsed: typeof input.collapsed === "boolean" ? input.collapsed : undefined,
+        },
+        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 (
+    toolName === "spawn_agent"
+    || toolName === "list_agents"
+    || toolName === "send_input"
+    || toolName === "wait_agent"
+    || toolName === "close_agent"
+  ) {
+    return {
+      kind: "tool",
+      toolKind: "mcp_generic",
+      toolName,
+      toolId,
+      input: {
+        server: "session-orchestration",
+        tool: toolName,
+        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,
+  }
+}
+
+const MAX_IMAGE_BASE64_LENGTH = 10 * 1024 * 1024 // ~7.5MB decoded
+
+const ALLOWED_IMAGE_MEDIA_TYPES = new Set([
+  "image/png", "image/jpeg", "image/gif", "image/webp", "image/svg+xml", "image/bmp",
+])
+
+function extractImageBlocks(parsed: unknown): ReadFileImageResult | null {
+  if (!Array.isArray(parsed)) return null
+
+  const images: ImageContentBlock[] = []
+  let text: string | undefined
+
+  for (const block of parsed) {
+    const record = asRecord(block)
+    if (!record) continue
+
+    if (record.type === "image") {
+      const source = asRecord(record.source)
+      if (
+        source &&
+        source.type === "base64" &&
+        typeof source.media_type === "string" &&
+        ALLOWED_IMAGE_MEDIA_TYPES.has(source.media_type) &&
+        typeof source.data === "string" &&
+        source.data.length <= MAX_IMAGE_BASE64_LENGTH
+      ) {
+        images.push({ mediaType: source.media_type, data: source.data })
+      }
+    }
+
+    if (record.type === "text" && typeof record.text === "string") {
+      text = text ? `${text}\n${record.text}` : record.text
+    }
+  }
+
+  if (images.length === 0) return null
+  return { images, text }
+}
+
+function parseJsonValue(value: unknown): unknown {
+  if (typeof value !== "string") return value
+  try {
+    return JSON.parse(value)
+  } catch (error: unknown) {
+    void error
+    return value
+  }
+}
+
+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 imageResult = extractImageBlocks(parsed)
+      if (imageResult) return imageResult
+      const record = asRecord(parsed)
+      return {
+        content: typeof record?.content === "string" ? record.content : JSON.stringify(parsed, null, 2),
+      } satisfies ReadFileToolResult
+    }
+    case "present_content": {
+      const record = asRecord(parsed)
+      if (isPresentContentSchemaValidationError(record?.error)) {
+        return {
+          error: record.error,
+        } satisfies PresentContentErrorToolResult
+      }
+      if (typeof record?.error === "string") {
+        return {
+          error: {
+            source: "schema_validation",
+            schema: "present_content",
+            issues: [
+              {
+                path: [],
+                code: "custom",
+                message: record.error,
+              },
+            ],
+          },
+        } satisfies PresentContentErrorToolResult
+      }
+      return {
+        accepted: true,
+        title: typeof record?.title === "string" ? record.title : tool.input.title,
+        kind: isPresentContentKind(record?.kind) ? record.kind : tool.input.kind,
+        format: typeof record?.format === "string" ? record.format : tool.input.format,
+        source: typeof record?.source === "string" ? record.source : tool.input.source,
+        summary: typeof record?.summary === "string" ? record.summary : tool.input.summary,
+        collapsed: typeof record?.collapsed === "boolean" ? record.collapsed : tool.input.collapsed,
+      } satisfies PresentContentToolResult
+    }
+    default: {
+      const imageResult = extractImageBlocks(parsed)
+      if (imageResult) return imageResult
+      return parsed
+    }
+  }
+}

package/src/shared/transcript-entries.ts

@@ -0,0 +1,27 @@
+import type { NormalizedToolCall, TranscriptEntry } from "./types"
+
+export function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+  createdAt = Date.now()
+): TranscriptEntry {
+  return {
+    _id: crypto.randomUUID(),
+    createdAt,
+    ...entry,
+  } as TranscriptEntry
+}
+
+export function discardedToolResult(
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+) {
+  if (tool.toolKind === "ask_user_question") {
+    return {
+      discarded: true,
+      answers: {},
+    }
+  }
+
+  return {
+    discarded: true,
+  }
+}

package/src/shared/transcript-render.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, test } from "bun:test"
+import type { NormalizedToolCall, TranscriptEntry } from "./types"
+import {
+  foldTranscriptRenderUnits,
+  getTranscriptRenderUnitId,
+} from "./transcript-render"
+
+let sequence = 0
+
+function entry<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(partial: T): TranscriptEntry {
+  sequence += 1
+  return {
+    _id: `e${sequence}`,
+    createdAt: sequence,
+    ...partial,
+  } as TranscriptEntry
+}
+
+function text(value: string): TranscriptEntry {
+  return entry({ kind: "assistant_text", text: value })
+}
+
+function user(content = "Hello"): TranscriptEntry {
+  return entry({ kind: "user_prompt", content })
+}
+
+function result(value = "Done"): TranscriptEntry {
+  return entry({
+    kind: "result",
+    subtype: "success",
+    isError: false,
+    durationMs: 100,
+    result: value,
+  })
+}
+
+function status(value: string): TranscriptEntry {
+  return entry({ kind: "status", status: value })
+}
+
+function toolCall(tool: NormalizedToolCall): TranscriptEntry {
+  return entry({ kind: "tool_call", tool })
+}
+
+function toolResult(toolId: string, content: unknown, isError = false): TranscriptEntry {
+  return entry({ kind: "tool_result", toolId, content, isError })
+}
+
+function bash(toolId: string, command = "echo hi"): TranscriptEntry {
+  return toolCall({
+    kind: "tool",
+    toolKind: "bash",
+    toolName: "Bash",
+    toolId,
+    input: { command },
+  })
+}
+
+function erroredSkill(toolId: string): TranscriptEntry[] {
+  return [
+    toolCall({
+      kind: "tool",
+      toolKind: "skill",
+      toolName: "Skill",
+      toolId,
+      input: { skill: "missing" },
+    }),
+    toolResult(toolId, "Skill not found: missing", true),
+  ]
+}
+
+function askUser(toolId: string): TranscriptEntry {
+  return toolCall({
+    kind: "tool",
+    toolKind: "ask_user_question",
+    toolName: "AskUserQuestion",
+    toolId,
+    input: { questions: [{ question: "Pick one" }] },
+  })
+}
+
+function todoWrite(toolId: string, content: string): TranscriptEntry {
+  return toolCall({
+    kind: "tool",
+    toolKind: "todo_write",
+    toolName: "TodoWrite",
+    toolId,
+    input: { todos: [{ content, status: "pending", activeForm: content }] },
+  })
+}
+
+function presentContent(toolId: string): TranscriptEntry {
+  return toolCall({
+    kind: "tool",
+    toolKind: "present_content",
+    toolName: "present_content",
+    toolId,
+    input: {
+      title: "Artifact",
+      kind: "markdown",
+      format: "markdown",
+      source: "Hello",
+    },
+  })
+}
+
+function unknownTool(toolId: string): TranscriptEntry {
+  return toolCall({
+    kind: "tool",
+    toolKind: "unknown_tool",
+    toolName: "FutureTool",
+    toolId,
+    input: { payload: { hello: "world" } },
+  })
+}
+
+describe("getTranscriptRenderUnitId", () => {
+  test("uses deterministic prefixed ids", () => {
+    expect(getTranscriptRenderUnitId("assistant_response", ["e1"])).toBe("assistant_response:e1")
+    expect(getTranscriptRenderUnitId("wip_block", ["e1", "e2", "e3"])).toBe("wip:e1:e3")
+    expect(getTranscriptRenderUnitId("tool_group", ["e2", "e3"])).toBe("tools:e2:e3")
+    expect(getTranscriptRenderUnitId("artifact", ["e4"])).toBe("artifact:e4")
+    expect(getTranscriptRenderUnitId("unknown", ["e5"])).toBe("unknown:e5")
+  })
+})
+
+describe("foldTranscriptRenderUnits", () => {
+  test("returns an empty render window for an empty transcript", () => {
+    expect(foldTranscriptRenderUnits([])).toEqual([])
+  })
+
+  test("folds narration plus work tool into WIP and final text into response", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([text("Checking"), bash("t1"), text("Fixed")])
+    expect(units.map((unit) => unit.kind)).toEqual(["wip_block", "assistant_response"])
+    expect(units[0]?.id).toBe("wip:e1:e2")
+    expect(units[1]?.id).toBe("assistant_response:e3")
+  })
+
+  test("ejects rationale text before interactive question", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([
+      text("Checking"),
+      bash("t1"),
+      text("Pick one:"),
+      askUser("q1"),
+    ], { isLoading: true })
+    expect(units.map((unit) => unit.kind)).toEqual(["wip_block", "assistant_response", "standalone_tool"])
+    expect(units[1]?.sourceEntryIds).toEqual(["e3"])
+  })
+
+  test("keeps only the latest TodoWrite projection visible", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([
+      todoWrite("todo-1", "old"),
+      text("Working"),
+      todoWrite("todo-2", "new"),
+    ], { isLoading: true })
+    expect(units.map((unit) => unit.kind)).toEqual(["wip_block", "standalone_tool"])
+    expect(units[1]?.sourceEntryIds).toEqual(["e3"])
+  })
+
+  test("renders present_content as an artifact unit, not a tool", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([presentContent("p1")])
+    expect(units.map((unit) => unit.kind)).toEqual(["artifact"])
+    expect(units[0]?.id).toBe("artifact:e1")
+  })
+
+  test("keeps errored tools standalone and visible", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([text("Trying skill"), ...erroredSkill("s1"), text("Failed")])
+    expect(units.map((unit) => unit.kind)).toEqual(["assistant_response", "standalone_tool", "assistant_response"])
+    expect(units[1]?.sourceEntryIds).toEqual(["e2", "e3"])
+  })
+
+  test("deduplicates system_init and account_info by first visible entry", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([
+      entry({ kind: "system_init", provider: "claude", model: "sonnet", tools: [], agents: [], slashCommands: [], mcpServers: [] }),
+      entry({ kind: "system_init", provider: "claude", model: "sonnet", tools: [], agents: [], slashCommands: [], mcpServers: [] }),
+      entry({ kind: "account_info", accountInfo: { email: "a@example.com" } }),
+      entry({ kind: "account_info", accountInfo: { email: "b@example.com" } }),
+    ])
+    expect(units.map((unit) => unit.kind)).toEqual(["system_init", "account_info"])
+    expect(units.map((unit) => unit.sourceEntryIds[0])).toEqual(["e1", "e3"])
+  })
+
+  test("renders only latest status and hides result next to context_cleared", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([
+      status("running"),
+      status("waiting_for_user"),
+      result("Session compacted"),
+      entry({ kind: "context_cleared" }),
+    ], { isLoading: true })
+    expect(units.map((unit) => unit.kind)).toEqual(["context_cleared", "status"])
+    expect(units[1]?.sourceEntryIds).toEqual(["e2"])
+  })
+
+  test("unknown tools render standalone instead of hiding", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([unknownTool("u1")])
+    expect(units.map((unit) => unit.kind)).toEqual(["standalone_tool"])
+  })
+
+  test("does not crash on pending tools or interrupted streams", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([text("Working"), bash("t1"), entry({ kind: "interrupted" })], { isLoading: true })
+    expect(units.map((unit) => unit.kind)).toEqual(["wip_block", "interrupted"])
+  })
+
+  test("does not group across consecutive user prompts", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([user("one"), user("two"), text("Answer")])
+    expect(units.map((unit) => unit.kind)).toEqual(["user_prompt", "user_prompt", "assistant_response"])
+  })
+
+  test("groups consecutive work tools outside assistant WIP context as a tool group", () => {
+    sequence = 0
+    const units = foldTranscriptRenderUnits([bash("t1"), bash("t2")])
+    expect(units.map((unit) => unit.kind)).toEqual(["tool_group"])
+    expect(units[0]?.id).toBe("tools:e1:e2")
+  })
+})