@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/shared/loop-progress.ts

@@ -0,0 +1,88 @@
+import type {
+  LoopProgressSnapshot,
+  LoopRateLimitInfo,
+  LoopRow,
+  LoopRowStatus,
+  SubagentRunSnapshot,
+} from "./types"
+
+/**
+ * Loop Progress — a per-chat, read-only view of an armed autonomous loop's
+ * work, surfaced as a checklist panel (mockup: a "Progress" card with one row
+ * per chunk). Event-sourced per round: each background subagent delegation the
+ * loop fires becomes one row, its status driven by the existing subagent-run
+ * lifecycle events. A rate-limited loop (see the rate-limit-resilience fix)
+ * surfaces a distinct "resume" affordance instead of looking silently stuck.
+ *
+ * These helpers are pure so the server read-model and the client share one
+ * shape; the DTO types live in ./types to avoid a runtime import cycle.
+ */
+
+const MAX_LABEL = 80
+
+/**
+ * First non-blank line of a spawn prompt, stripped of a single leading markdown
+ * marker (heading / list / quote / ordinal) and capped to a chip-friendly
+ * length. Deterministic and side-effect free so it can run at delegate time on
+ * the server and be asserted in unit tests.
+ */
+export function deriveChunkLabel(prompt: string): string {
+  const firstLine =
+    prompt
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0) ?? ""
+  const stripped = firstLine.replace(/^(#{1,6}\s+|[-*+]\s+|\d+[.)]\s+|>\s+)/, "").trim()
+  const cleaned = stripped.length > 0 ? stripped : firstLine
+  if (cleaned.length <= MAX_LABEL) return cleaned
+  return `${cleaned.slice(0, MAX_LABEL - 1).trimEnd()}…`
+}
+
+function rowStatusFor(run: SubagentRunSnapshot): LoopRowStatus {
+  switch (run.status) {
+    case "running":
+      return "running"
+    case "completed":
+      return "done"
+    default:
+      // failed | cancelled | any future terminal-failure state
+      return "failed"
+  }
+}
+
+export interface BuildLoopProgressInput {
+  chatId: string
+  armed: boolean
+  /** Timestamp of the current `loop_armed` event; rows before it are excluded. */
+  loopArmedAt: number | null
+  /** All subagent runs for the chat (any order). */
+  runs: readonly SubagentRunSnapshot[]
+  rateLimit: LoopRateLimitInfo | null
+}
+
+/**
+ * Fold the chat's subagent runs + loop/rate-limit state into the panel DTO.
+ * Only top-level (depth 0) runs started since the loop was armed count as loop
+ * rows — nested sub-spawns and pre-loop delegations are excluded. Rows are
+ * sorted newest-first.
+ */
+export function buildLoopProgress(input: BuildLoopProgressInput): LoopProgressSnapshot {
+  const since = input.loopArmedAt ?? 0
+  const rows: LoopRow[] = input.runs
+    .filter((run) => run.depth === 0 && run.startedAt >= since)
+    .map((run) => ({
+      runId: run.runId,
+      label: run.label ?? run.subagentName,
+      status: rowStatusFor(run),
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt,
+    }))
+    .sort((a, b) => b.startedAt - a.startedAt)
+
+  return {
+    chatId: input.chatId,
+    armed: input.armed,
+    rows,
+    rateLimit: input.rateLimit,
+  }
+}

package/src/shared/mcp-types.ts

@@ -0,0 +1,105 @@
+// MCP (Model Context Protocol) server types.
+// Extracted from types.ts to keep the barrel lean.
+// All external consumers importing from "../shared/types" continue to work unchanged.
+
+import type {
+  OAuthTokens,
+  OAuthClientInformationFull,
+  AuthorizationServerMetadata,
+} from "@modelcontextprotocol/sdk/shared/auth.js"
+
+export type McpServerTransport = "stdio" | "http" | "sse" | "ws"
+
+export type McpServerTestResult =
+  | { status: "untested" }
+  | { status: "pending"; startedAt: string }
+  | { status: "ok"; testedAt: string; toolCount: number }
+  | { status: "error"; testedAt: string; message: string }
+
+export interface McpOAuthFlowState {
+  codeVerifier: string
+  state: string
+  issuer: string
+  authorizationUrl: string
+  // AS metadata cached between start and complete (avoids re-discovery)
+  metadata: AuthorizationServerMetadata
+}
+
+export interface McpOAuthState {
+  enabled: boolean
+  status: "unauthenticated" | "authenticated" | "error"
+  errorMessage?: string
+  // resolved AS issuer (set on complete; used by refresh without re-discovery)
+  issuer?: string
+  // cached AS metadata (token_endpoint, etc.) persisted at complete so refresh
+  // uses it directly instead of re-discovering from issuer (which may be a
+  // non-resolvable resource URL, e.g. claude.ai design MCP)
+  metadata?: AuthorizationServerMetadata
+  // DCR result keyed by AS issuer (SEP-2352)
+  clientByIssuer?: Record<string, OAuthClientInformationFull>
+  tokens?: OAuthTokens
+  obtainedAt?: number
+  // present only mid-flow; cleared on complete/cancel
+  flow?: McpOAuthFlowState
+}
+
+interface McpServerBase {
+  id: string
+  name: string
+  enabled: boolean
+  createdAt: string
+  updatedAt: string
+  lastTest: McpServerTestResult
+}
+
+export interface McpServerStdioFields {
+  transport: "stdio"
+  command: string
+  args: string[]
+  env: Record<string, string>
+  cwd?: string
+}
+
+export interface McpServerNetworkFields {
+  transport: "http" | "sse" | "ws"
+  url: string
+  headers: Record<string, string>
+  oauth?: McpOAuthState
+}
+
+export type McpServerConfig =
+  | (McpServerBase & McpServerStdioFields)
+  | (McpServerBase & McpServerNetworkFields)
+
+export type McpServerInput =
+  | (McpServerStdioFields & { name: string; enabled?: boolean })
+  | (McpServerNetworkFields & { name: string; enabled?: boolean })
+
+export type McpServerPatch = Partial<{
+  name: string
+  enabled: boolean
+  transport: McpServerTransport
+  command: string
+  args: string[]
+  env: Record<string, string>
+  cwd: string | undefined
+  url: string
+  headers: Record<string, string>
+  oauth: McpOAuthState
+}>
+
+export interface McpValidationError {
+  code:
+    | "INVALID_NAME"
+    | "DUPLICATE_NAME"
+    | "RESERVED_NAME"
+    | "INVALID_TRANSPORT"
+    | "MISSING_COMMAND"
+    | "INVALID_URL"
+    | "INVALID_HEADER_KEY"
+    | "INVALID_ENV_KEY"
+    | "NOT_FOUND"
+    | "INVALID_OAUTH_TRANSPORT"
+  field?: string
+  message: string
+}

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
+  }
+}