@cuongtran001/kanna 1.3.0 → 1.3.1

package/src/shared/provider-model-types.ts

@@ -0,0 +1,437 @@
+/**
+ * Provider and model catalog types — extracted from shared/types.ts.
+ * Imported via the re-export barrel in types.ts; all external consumers
+ * continue to import from "../shared/types" unchanged.
+ */
+
+// AgentProvider lives in types.ts and is only needed as a type here.
+// import type = erased at compile time → no circular runtime dependency.
+import type { AgentProvider } from "./types"
+
+export const DEFAULT_OPENROUTER_SDK_MODEL = "moonshotai/kimi-k2.5:nitro"
+
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api"
+export const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models"
+
+export interface OpenRouterModel {
+  id: string
+  label: string
+  contextLength: number
+  pricing?: { promptPerTok: number; completionPerTok: number }
+}
+
+// ---------------------------------------------------------------------------
+// Provider model option primitives
+// ---------------------------------------------------------------------------
+
+export interface ProviderModelOption {
+  id: string
+  label: string
+  supportsEffort: boolean
+  aliases?: readonly string[]
+  contextWindowOptions?: readonly ProviderContextWindowOption[]
+  supportsMaxReasoningEffort?: boolean
+}
+
+export interface ProviderEffortOption {
+  id: string
+  label: string
+}
+
+export interface ProviderContextWindowOption {
+  id: ClaudeContextWindow
+  label: string
+}
+
+export const CLAUDE_REASONING_OPTIONS = [
+  { id: "low", label: "Low" },
+  { id: "medium", label: "Medium" },
+  { id: "high", label: "High" },
+  { id: "max", label: "Max" },
+] as const satisfies readonly ProviderEffortOption[]
+
+export const CODEX_REASONING_OPTIONS = [
+  { id: "minimal", label: "Minimal" },
+  { id: "low", label: "Low" },
+  { id: "medium", label: "Medium" },
+  { id: "high", label: "High" },
+  { id: "xhigh", label: "XHigh" },
+] as const satisfies readonly ProviderEffortOption[]
+
+export type ClaudeReasoningEffort = (typeof CLAUDE_REASONING_OPTIONS)[number]["id"]
+export type CodexReasoningEffort = (typeof CODEX_REASONING_OPTIONS)[number]["id"]
+export type ClaudeContextWindow = "200k" | "1m"
+export type ServiceTier = "fast"
+
+export interface ClaudeModelOptions {
+  reasoningEffort: ClaudeReasoningEffort
+  contextWindow: ClaudeContextWindow
+}
+
+export interface CodexModelOptions {
+  reasoningEffort: CodexReasoningEffort
+  fastMode: boolean
+}
+
+export type OpenRouterModelOptions = Record<string, never>
+
+export interface ProviderModelOptionsByProvider {
+  claude: ClaudeModelOptions
+  codex: CodexModelOptions
+  openrouter: OpenRouterModelOptions
+}
+
+export interface ProviderPreference<TModelOptions> {
+  model: string
+  modelOptions: TModelOptions
+  planMode: boolean
+}
+
+export type ChatProviderPreferences = {
+  claude: ProviderPreference<ClaudeModelOptions>
+  codex: ProviderPreference<CodexModelOptions>
+  openrouter: ProviderPreference<OpenRouterModelOptions>
+}
+
+// ---------------------------------------------------------------------------
+// Model option defaults and type-guards
+// ---------------------------------------------------------------------------
+
+export type ModelOptions = Partial<{
+  [K in AgentProvider]: Partial<ProviderModelOptionsByProvider[K]>
+}>
+
+export const DEFAULT_CLAUDE_MODEL_OPTIONS = {
+  reasoningEffort: "high",
+  contextWindow: "200k",
+} as const satisfies ClaudeModelOptions
+
+export const DEFAULT_CODEX_MODEL_OPTIONS = {
+  reasoningEffort: "high",
+  fastMode: false,
+} as const satisfies CodexModelOptions
+
+export function isClaudeReasoningEffort(value: string | null | undefined): value is ClaudeReasoningEffort {
+  return CLAUDE_REASONING_OPTIONS.some((option) => option.id === value)
+}
+
+export function isCodexReasoningEffort(value: string | null | undefined): value is CodexReasoningEffort {
+  return CODEX_REASONING_OPTIONS.some((option) => option.id === value)
+}
+
+export const CLAUDE_CONTEXT_WINDOW_OPTIONS = [
+  { id: "200k", label: "200k" },
+  { id: "1m", label: "1M" },
+] as const satisfies readonly ProviderContextWindowOption[]
+
+export function isClaudeContextWindow(value: string | null | undefined): value is ClaudeContextWindow {
+  return CLAUDE_CONTEXT_WINDOW_OPTIONS.some((option) => option.id === value)
+}
+
+// ---------------------------------------------------------------------------
+// Provider catalog
+// ---------------------------------------------------------------------------
+
+export interface ProviderCatalogEntry {
+  id: AgentProvider
+  label: string
+  defaultModel: string
+  defaultEffort?: string
+  supportsPlanMode: boolean
+  models: ProviderModelOption[]
+  efforts: ProviderEffortOption[]
+}
+
+export const PROVIDERS: ProviderCatalogEntry[] = [
+  {
+    id: "claude",
+    label: "Claude",
+    defaultModel: "claude-sonnet-4-6",
+    defaultEffort: "high",
+    supportsPlanMode: true,
+    models: [
+      {
+        id: "claude-fable-5",
+        label: "Fable 5",
+        supportsEffort: true,
+        aliases: ["fable"],
+        contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS],
+        supportsMaxReasoningEffort: true,
+      },
+      {
+        id: "claude-opus-4-7",
+        label: "Opus 4.7",
+        supportsEffort: true,
+        aliases: ["opus"],
+        contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS],
+        supportsMaxReasoningEffort: true,
+      },
+      {
+        id: "claude-sonnet-4-6",
+        label: "Sonnet 4.6",
+        supportsEffort: true,
+        aliases: ["sonnet"],
+        contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS],
+      },
+      {
+        id: "claude-haiku-4-5-20251001",
+        label: "Haiku 4.5",
+        supportsEffort: true,
+        aliases: ["haiku"],
+      },
+      {
+        id: "claude-opus-4-8",
+        label: "Opus 4.8",
+        supportsEffort: true,
+        aliases: ["opus-4-8"],
+        contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS],
+        supportsMaxReasoningEffort: true,
+      },
+    ],
+    efforts: [...CLAUDE_REASONING_OPTIONS],
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    defaultModel: "gpt-5.5",
+    supportsPlanMode: true,
+    models: [
+      { id: "gpt-5.5", label: "GPT-5.5", supportsEffort: false },
+      { id: "gpt-5.4", label: "GPT-5.4", supportsEffort: false },
+      { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", supportsEffort: false, aliases: ["gpt-5-codex"] },
+      { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", supportsEffort: false },
+    ],
+    efforts: [],
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter",
+    defaultModel: DEFAULT_OPENROUTER_SDK_MODEL,
+    supportsPlanMode: true,
+    models: [],
+    efforts: [],
+  },
+]
+
+export function getProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+  const entry = PROVIDERS.find((candidate) => candidate.id === provider)
+  if (!entry) {
+    throw new Error(`Unknown provider: ${provider}`)
+  }
+  return entry
+}
+
+// ---------------------------------------------------------------------------
+// Custom model entries (user-configurable overrides over the catalog)
+// ---------------------------------------------------------------------------
+
+export interface CustomModelEntry {
+  id: string
+  label: string
+  provider: "claude" | "codex"
+  supportsEffort: boolean
+  aliases?: readonly string[]
+  contextWindowOptions?: readonly ProviderContextWindowOption[]
+  supportsMaxReasoningEffort?: boolean
+  createdAt: number
+  updatedAt: number
+}
+
+export interface CustomModelInput {
+  id: string
+  label: string
+  provider: "claude" | "codex"
+  supportsEffort: boolean
+  aliases?: readonly string[]
+  contextWindowOptions?: readonly ProviderContextWindowOption[]
+  supportsMaxReasoningEffort?: boolean
+}
+
+export interface CustomModelPatch {
+  label?: string
+  supportsEffort?: boolean
+  aliases?: readonly string[] | null
+  contextWindowOptions?: readonly ProviderContextWindowOption[] | null
+  supportsMaxReasoningEffort?: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Text snippets (keyboard-shortcut text expansions)
+// ---------------------------------------------------------------------------
+
+export interface TextSnippet {
+  id: string
+  shortcut: string
+  expansion: string
+  createdAt: number
+  updatedAt: number
+}
+
+export interface TextSnippetInput {
+  shortcut: string
+  expansion: string
+}
+
+export interface TextSnippetPatch {
+  shortcut?: string
+  expansion?: string
+}
+
+// ---------------------------------------------------------------------------
+// mergeCustomModels — folds user overrides into the provider catalog
+// ---------------------------------------------------------------------------
+
+function customEntryToModelOption(entry: CustomModelEntry): ProviderModelOption {
+  return {
+    id: entry.id,
+    label: entry.label,
+    supportsEffort: entry.supportsEffort,
+    ...(entry.aliases ? { aliases: entry.aliases } : {}),
+    ...(entry.contextWindowOptions ? { contextWindowOptions: entry.contextWindowOptions } : {}),
+    ...(entry.supportsMaxReasoningEffort !== undefined ? { supportsMaxReasoningEffort: entry.supportsMaxReasoningEffort } : {}),
+  }
+}
+
+export function mergeCustomModels(
+  base: ProviderCatalogEntry[],
+  customModels: readonly CustomModelEntry[],
+): ProviderCatalogEntry[] {
+  return base.map((entry) => {
+    if (entry.id !== "claude" && entry.id !== "codex") return { ...entry, models: [...entry.models] }
+    const forProvider = customModels.filter((m) => m.provider === entry.id)
+    if (forProvider.length === 0) return { ...entry, models: [...entry.models] }
+    const models = [...entry.models]
+    for (const custom of forProvider) {
+      const option = customEntryToModelOption(custom)
+      const idx = models.findIndex((m) => m.id === option.id)
+      if (idx >= 0) models[idx] = option
+      else models.push(option)
+    }
+    return { ...entry, models }
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Provider session helpers and model-id normalization
+// ---------------------------------------------------------------------------
+
+/**
+ * True when the provider's turns run through the Claude SDK session transport
+ * (a live `claudeSessions` entry consumed by `runClaudeSession`, prompts
+ * delivered via `session.sendPrompt`) rather than the generic harness-turn
+ * transport (`runTurn` over `active.turn.stream`).
+ *
+ * `claude` and `openrouter` both ride the SDK session — openrouter just points
+ * the SDK at OpenRouter's Anthropic-compatible endpoint. Branching on
+ * `provider === "claude"` where the real intent is "uses the SDK session" is
+ * what silently dropped openrouter's prompt delivery; use this predicate so a
+ * new SDK-backed provider can never be forgotten by an `if`-chain again.
+ */
+export function providerUsesSdkSession(provider: AgentProvider): boolean {
+  return provider === "claude" || provider === "openrouter"
+}
+
+function catalogModelsFor(
+  provider: AgentProvider,
+  customModels?: readonly CustomModelEntry[],
+): readonly ProviderModelOption[] {
+  const catalog = getProviderCatalog(provider)
+  if (!customModels || customModels.length === 0) return catalog.models
+  const [merged] = mergeCustomModels([{ ...catalog, models: [...catalog.models] }], customModels)
+  return merged.models
+}
+
+function getProviderModelMatch(
+  provider: AgentProvider,
+  modelId?: string,
+  customModels?: readonly CustomModelEntry[],
+): ProviderModelOption | undefined {
+  if (!modelId) return undefined
+
+  return catalogModelsFor(provider, customModels).find((candidate) =>
+    candidate.id === modelId || candidate.aliases?.includes(modelId)
+  )
+}
+
+export function normalizeProviderModelId(
+  provider: AgentProvider,
+  modelId?: string,
+  fallbackModelId?: string,
+  customModels?: readonly CustomModelEntry[],
+): string {
+  return getProviderModelMatch(provider, modelId, customModels)?.id
+    ?? fallbackModelId
+    ?? getProviderCatalog(provider).defaultModel
+}
+
+export function normalizeClaudeModelId(
+  modelId?: string,
+  fallbackModelId = "claude-opus-4-7",
+  customModels?: readonly CustomModelEntry[],
+): string {
+  return normalizeProviderModelId("claude", modelId, fallbackModelId, customModels)
+}
+
+export function normalizeCodexModelId(
+  modelId?: string,
+  fallbackModelId = "gpt-5.5",
+  customModels?: readonly CustomModelEntry[],
+): string {
+  return normalizeProviderModelId("codex", modelId, fallbackModelId, customModels)
+}
+
+export function getProviderModelOption(
+  provider: AgentProvider,
+  modelId: string,
+  customModels?: readonly CustomModelEntry[],
+): ProviderModelOption | undefined {
+  const normalizedModelId = normalizeProviderModelId(provider, modelId, undefined, customModels)
+  return catalogModelsFor(provider, customModels).find((candidate) => candidate.id === normalizedModelId)
+}
+
+export function getClaudeModelOption(
+  modelId: string,
+  customModels?: readonly CustomModelEntry[],
+): ProviderModelOption | undefined {
+  return getProviderModelOption("claude", modelId, customModels)
+}
+
+export function supportsClaudeMaxReasoningEffort(
+  modelId: string,
+  customModels?: readonly CustomModelEntry[],
+): boolean {
+  return Boolean(getClaudeModelOption(modelId, customModels)?.supportsMaxReasoningEffort)
+}
+
+export function getClaudeContextWindowOptions(
+  modelId: string,
+  customModels?: readonly CustomModelEntry[],
+): readonly ProviderContextWindowOption[] {
+  return getClaudeModelOption(modelId, customModels)?.contextWindowOptions ?? []
+}
+
+export function normalizeClaudeContextWindow(
+  modelId: string,
+  contextWindow?: string,
+  customModels?: readonly CustomModelEntry[],
+): ClaudeContextWindow {
+  const options = getClaudeContextWindowOptions(modelId, customModels)
+  if (options.length === 0) return DEFAULT_CLAUDE_MODEL_OPTIONS.contextWindow
+  return isClaudeContextWindow(contextWindow) && options.some((option) => option.id === contextWindow)
+    ? contextWindow
+    : DEFAULT_CLAUDE_MODEL_OPTIONS.contextWindow
+}
+
+export function resolveClaudeApiModelId(modelId: string, contextWindow?: ClaudeContextWindow): string {
+  return contextWindow === "1m" ? `${modelId}[1m]` : modelId
+}
+
+export function resolveClaudeContextWindowTokens(contextWindow: ClaudeContextWindow): number {
+  switch (contextWindow) {
+    case "1m":
+      return 1_000_000
+    case "200k":
+    default:
+      return 200_000
+  }
+}

package/src/shared/subagent-types.ts

@@ -0,0 +1,198 @@
+// Subagent domain types: definitions, runtime snapshots, loop progress.
+// Extracted from types.ts to keep the barrel lean.
+// All external consumers importing from "../shared/types" continue to work unchanged.
+
+import type { AgentProvider } from "./core-types"
+import type { ClaudeModelOptions, CodexModelOptions } from "./provider-model-types"
+import type { TranscriptEntry } from "./transcript-types"
+
+export type SubagentContextScope = "previous-assistant-reply" | "full-transcript"
+
+export type SubagentTriggerMode = "auto" | "manual"
+
+export interface SubagentRestriction {
+  workingDir?: string
+  allowedPaths?: string[]
+}
+
+export interface Subagent {
+  id: string
+  name: string
+  description?: string
+  provider: AgentProvider
+  model: string
+  modelOptions: ClaudeModelOptions | CodexModelOptions
+  systemPrompt: string
+  contextScope: SubagentContextScope
+  triggerMode: SubagentTriggerMode
+  workingDir?: string
+  allowedPaths?: string[]
+  // Per-subagent agentic-turn bound — the analog of Claude Code's agent
+  // frontmatter `maxTurns`. Unset = unbounded (Claude Code's default).
+  // Claude-SDK runs pass it natively to query() (graceful stop, output kept);
+  // PTY/Codex runs get a host-side tool-call-count backstop (hard abort).
+  maxTurns?: number
+  createdAt: number
+  updatedAt: number
+}
+
+export interface SubagentInput {
+  name: string
+  description?: string
+  provider: AgentProvider
+  model: string
+  modelOptions: ClaudeModelOptions | CodexModelOptions
+  systemPrompt: string
+  contextScope: SubagentContextScope
+  triggerMode?: SubagentTriggerMode
+  workingDir?: string
+  allowedPaths?: string[]
+  maxTurns?: number
+}
+
+export interface SubagentPatch {
+  name?: string
+  description?: string | null
+  provider?: AgentProvider
+  model?: string
+  modelOptions?: Partial<ClaudeModelOptions> | Partial<CodexModelOptions>
+  systemPrompt?: string
+  contextScope?: SubagentContextScope
+  triggerMode?: SubagentTriggerMode
+  workingDir?: string | null
+  allowedPaths?: string[] | null
+  maxTurns?: number | null
+}
+
+export type SubagentValidationErrorCode =
+  | "EMPTY_NAME"
+  | "INVALID_CHAR"
+  | "RESERVED_NAME"
+  | "DUPLICATE_NAME"
+  | "TOO_LONG"
+  | "NOT_FOUND"
+  | "RESTRICTION_NOT_SUPPORTED"
+  | "INVALID_PATH"
+  | "PATH_ESCAPE"
+  | "EMPTY_ALLOWED_PATHS"
+
+export interface SubagentValidationError {
+  code: SubagentValidationErrorCode
+  message: string
+}
+
+export type SubagentErrorCode =
+  | "AUTH_REQUIRED"
+  | "UNKNOWN_SUBAGENT"
+  | "MANUAL_ONLY"
+  | "LOOP_DETECTED"
+  | "DEPTH_EXCEEDED"
+  | "TIMEOUT"
+  | "MAX_TURNS"
+  | "PROVIDER_ERROR"
+  | "INTERRUPTED"
+  | "USER_CANCELLED"
+  | "CAP_EXCEEDED"
+  | "NO_LIVE_SESSION"
+
+export type SubagentRunStatus = "running" | "completed" | "failed" | "cancelled"
+
+export interface ProviderUsage {
+  inputTokens?: number
+  outputTokens?: number
+  cachedInputTokens?: number
+  costUsd?: number
+}
+
+export interface SubagentPendingTool {
+  toolUseId: string
+  toolKind: "ask_user_question" | "exit_plan_mode"
+  input: Record<string, unknown>
+  requestedAt: number
+}
+
+export interface SubagentRunSnapshot {
+  runId: string
+  chatId: string
+  subagentId: string | null
+  subagentName: string
+  /**
+   * Short human label for this run, derived from the first line of the spawn
+   * prompt (e.g. "Migrate useKannaState.ts"). Null for runs started before this
+   * field existed or by error paths that never carried a prompt. Drives the
+   * Loop Progress panel rows so each round reads as the chunk it worked on
+   * rather than an opaque run id.
+   */
+  label: string | null
+  provider: AgentProvider
+  model: string
+  status: SubagentRunStatus
+  parentUserMessageId: string
+  parentRunId: string | null
+  depth: number
+  startedAt: number
+  finishedAt: number | null
+  finalText: string | null
+  error: { code: SubagentErrorCode; message: string } | null
+  usage: ProviderUsage | null
+  /**
+   * Every TranscriptEntry the subagent produced, in arrival order. Includes
+   * tool_call, tool_result, system_init, account_info, result. assistant_text
+   * entries also live here in addition to being concatenated into finalText
+   * via subagent_message_delta — clients should prefer entries[] for rich
+   * rendering, finalText only as a quick text-only summary.
+   */
+  entries: TranscriptEntry[]
+  /**
+   * Set while the subagent is awaiting a user response to an
+   * interactive tool call (AskUserQuestion / ExitPlanMode). Null
+   * otherwise. The orchestrator's wall-clock timeout is paused while
+   * this is non-null.
+   */
+  pendingTool: SubagentPendingTool | null
+}
+
+export type LoopRowStatus = "pending" | "running" | "done" | "failed"
+
+export interface LoopRow {
+  runId: string
+  label: string
+  status: LoopRowStatus
+  startedAt: number
+  finishedAt: number | null
+}
+
+export interface LoopRateLimitInfo {
+  /** The live auto-continue schedule id, so the panel's Resume action can accept it. */
+  scheduleId: string
+  /** epoch ms the usage limit resets (and the resume is/would be scheduled for) */
+  resetAt: number
+  tz: string
+  /**
+   * true  → an auto-continue is already scheduled to fire at `resetAt`
+   *         (the loop resumes on its own).
+   * false → the resume is only proposed and waits on the user
+   *         (auto-resume setting off) — render a "Resume" action.
+   */
+  scheduled: boolean
+}
+
+export interface LoopProgressSnapshot {
+  chatId: string
+  /** Whether a loop is currently armed for this chat. */
+  armed: boolean
+  /** Latest first — most recent delegation at the top, mirroring PROGRESS.md. */
+  rows: LoopRow[]
+  /** Non-null while the loop is paused on a Claude usage limit. */
+  rateLimit: LoopRateLimitInfo | null
+}
+
+// Type guards
+
+export function isSubagentContextScope(value: string): value is SubagentContextScope {
+  return value === "previous-assistant-reply" || value === "full-transcript"
+}
+
+export function isSubagentTriggerMode(value: string): value is SubagentTriggerMode {
+  return value === "auto" || value === "manual"
+}