@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/claude-chat-management.ts

@@ -0,0 +1,251 @@
+/**
+ * Standalone chat management functions for AgentCoordinator.
+ *
+ * Extracted from agent.ts so the chat lifecycle and steering logic lives in
+ * its own testable module. The coordinator delegates to these functions by
+ * passing an object literal that satisfies `ChatManagementDeps`.
+ *
+ * Side-effect seal: this module contains NO direct IO (no node:fs, no HTTP
+ * calls, no Bun primitives). Every effectful operation is injected through
+ * the deps interface.
+ */
+
+import type { AgentProvider, QueuedChatMessage } from "../shared/types"
+import type { ClientCommand } from "../shared/protocol"
+import type { ClaudeSessionState } from "./claude-session-state"
+import type { GenerateChatTitleResult } from "./generate-title"
+import { logClaudeSteer } from "./claude-steer-log"
+
+// ---------------------------------------------------------------------------
+// Structural sub-interfaces — only the slices each function calls.
+// ---------------------------------------------------------------------------
+
+/** Subset of the activeTurns map used by chat management. */
+interface ActiveTurnsMap {
+  has(chatId: string): boolean
+  get(chatId: string): { proactiveCompactInjection?: boolean } | undefined
+}
+
+/** Subset of the drainingStreams map used by chat management. */
+interface DrainingStreamsMap {
+  get(chatId: string): { turn: { close(): void } } | undefined
+  has(chatId: string): boolean
+  delete(chatId: string): boolean
+}
+
+/** Subset of the claudeSessions map used by chat management. */
+interface ClaudeSessionsMap {
+  get(chatId: string): ClaudeSessionState | undefined
+}
+
+/** Subset of the autoResumeByChat map used by chat management. */
+interface AutoResumeMap {
+  delete(chatId: string): boolean
+}
+
+/** Subset of EventStore used by the chat management functions. */
+interface ChatManagementStore {
+  getQueuedMessage(chatId: string, queuedMessageId: string): QueuedChatMessage | null
+  removeQueuedMessage(chatId: string, queuedMessageId: string): Promise<void>
+  requireChat(chatId: string): {
+    title: string
+    provider: AgentProvider | null
+    sessionTokensByProvider: Partial<Record<AgentProvider, string | null>>
+    pendingForkSessionToken?: { provider: AgentProvider; token: string } | null
+  }
+  forkChat(chatId: string): Promise<{ id: string }>
+  renameChat(chatId: string, title: string): Promise<void>
+}
+
+/** Minimal analytics interface used by chat management. */
+interface AnalyticsSubset {
+  track(eventName: string, properties?: Record<string, unknown>): void
+}
+
+// ---------------------------------------------------------------------------
+// Dependency bundle injected by AgentCoordinator
+// ---------------------------------------------------------------------------
+
+export interface ChatManagementDeps {
+  /** Active turn map — read-only for management functions. */
+  activeTurns: ActiveTurnsMap
+  /** Draining streams map — management functions read and mutate it. */
+  drainingStreams: DrainingStreamsMap
+  /** Active Claude session map — used by closeChat to find the session. */
+  claudeSessions: ClaudeSessionsMap
+  /** Per-chat auto-resume flags — cleared on closeChat. */
+  autoResumeByChat: AutoResumeMap
+  /** Subset of EventStore needed by management functions. */
+  store: ChatManagementStore
+  /** Analytics reporter for tracking events. */
+  analytics: AnalyticsSubset
+  /** Cancel the active turn for a chat. */
+  cancel(chatId: string, options?: { hideInterrupted?: boolean; skipQueueDrain?: boolean }): Promise<void>
+  /** Close the Claude session for a chat, freeing its process slot. */
+  closeClaudeSession(chatId: string, session: ClaudeSessionState, opts?: { keepReservation?: boolean }): void
+  /** Notify listeners that the observable state for chatId has changed. */
+  emitStateChange(chatId: string): void
+  /** Generate a title for a chat message (AI-assisted). */
+  generateTitle(messageContent: string, cwd: string): Promise<GenerateChatTitleResult>
+  /** Report a non-fatal background error (e.g. title generation failure). Nullable for optional injection. */
+  reportBackgroundError: ((message: string) => void) | null
+  /** Dequeue a queued message and start processing it. */
+  dequeueAndStartQueuedMessage(
+    chatId: string,
+    queuedMessage: QueuedChatMessage,
+    options?: { steered?: boolean },
+  ): Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Extracted functions
+// ---------------------------------------------------------------------------
+
+/**
+ * Stop a draining stream for `chatId` if one is active.
+ * Closes the stream's turn, removes the entry, and notifies state listeners.
+ */
+export async function stopDraining(deps: ChatManagementDeps, chatId: string): Promise<void> {
+  const draining = deps.drainingStreams.get(chatId)
+  if (!draining) return
+  draining.turn.close()
+  deps.drainingStreams.delete(chatId)
+  deps.emitStateChange(chatId)
+}
+
+/**
+ * Fully close a chat: stop any draining stream, close the Claude session,
+ * clear the auto-resume flag, and notify state listeners.
+ */
+export async function closeChat(deps: ChatManagementDeps, chatId: string): Promise<void> {
+  await stopDraining(deps, chatId)
+  const claudeSession = deps.claudeSessions.get(chatId)
+  if (claudeSession) {
+    deps.closeClaudeSession(chatId, claudeSession)
+  }
+  deps.autoResumeByChat.delete(chatId)
+  deps.emitStateChange(chatId)
+}
+
+/**
+ * Steer a chat to a previously queued message: cancel the current active turn
+ * (if any) and immediately start the queued message.
+ */
+export async function steer(
+  deps: ChatManagementDeps,
+  command: Extract<ClientCommand, { type: "message.steer" }>,
+): Promise<void> {
+  const queuedMessage = deps.store.getQueuedMessage(command.chatId, command.queuedMessageId)
+  if (!queuedMessage) {
+    throw new Error("Queued message not found")
+  }
+
+  logClaudeSteer("steer_requested", {
+    chatId: command.chatId,
+    queuedMessageId: command.queuedMessageId,
+    activeTurn: deps.activeTurns.has(command.chatId),
+    queuedMessagePreview: queuedMessage.content.slice(0, 160),
+  })
+
+  if (deps.activeTurns.has(command.chatId)) {
+    await deps.cancel(command.chatId, { hideInterrupted: true, skipQueueDrain: true })
+  }
+
+  logClaudeSteer("steer_after_cancel", {
+    chatId: command.chatId,
+    stillActive: deps.activeTurns.has(command.chatId),
+  })
+
+  if (deps.activeTurns.has(command.chatId)) {
+    throw new Error("Chat is still running")
+  }
+
+  await deps.dequeueAndStartQueuedMessage(command.chatId, queuedMessage, { steered: true })
+}
+
+/**
+ * Remove a queued message, refusing if a proactive compact turn is in flight
+ * (dropping the message mid-compact would silently lose user intent).
+ */
+export async function dequeue(
+  deps: ChatManagementDeps,
+  command: Extract<ClientCommand, { type: "message.dequeue" }>,
+): Promise<void> {
+  const queuedMessage = deps.store.getQueuedMessage(command.chatId, command.queuedMessageId)
+  if (!queuedMessage) {
+    throw new Error("Queued message not found")
+  }
+
+  // Refuse to drop the queued message while a Kanna-injected `/compact`
+  // turn is running. The compact was triggered specifically to make room
+  // for this queued message; auto-draining it after compact completes
+  // would silently lose user intent and waste the compact spend.
+  const active = deps.activeTurns.get(command.chatId)
+  if (active?.proactiveCompactInjection) {
+    throw new Error("Cannot remove queued message while compact is running")
+  }
+
+  await deps.store.removeQueuedMessage(command.chatId, command.queuedMessageId)
+}
+
+/**
+ * Fork `chatId` into a new child chat, inheriting the parent's session token.
+ * Throws if the chat is active, has no provider, or has no session to fork.
+ */
+export async function forkChat(deps: ChatManagementDeps, chatId: string): Promise<{ chatId: string }> {
+  const chat = deps.store.requireChat(chatId)
+  if (deps.activeTurns.has(chatId) || deps.drainingStreams.has(chatId)) {
+    throw new Error("Chat must be idle before forking")
+  }
+  if (!chat.provider) {
+    throw new Error("Chat must have a provider before forking")
+  }
+  const currentProviderToken = chat.provider
+    ? (chat.sessionTokensByProvider[chat.provider] ?? null)
+    : null
+  const pendingForkForProvider =
+    chat.pendingForkSessionToken?.provider === chat.provider
+      ? chat.pendingForkSessionToken.token
+      : null
+  if (!currentProviderToken && !pendingForkForProvider) {
+    throw new Error("Chat has no session to fork")
+  }
+
+  const forked = await deps.store.forkChat(chatId)
+  deps.analytics.track("chat_created")
+  return { chatId: forked.id }
+}
+
+/**
+ * Generate a title for a chat message in the background, persisting it only
+ * if the chat's current title still matches `expectedCurrentTitle`.
+ * Errors are reported via `deps.reportBackgroundError` rather than thrown.
+ */
+export async function generateTitleInBackground(
+  deps: ChatManagementDeps,
+  chatId: string,
+  messageContent: string,
+  cwd: string,
+  expectedCurrentTitle: string,
+): Promise<void> {
+  try {
+    const result = await deps.generateTitle(messageContent, cwd)
+    if (result.failureMessage) {
+      deps.reportBackgroundError?.(
+        `[title-generation] chat ${chatId} failed provider title generation: ${result.failureMessage}`,
+      )
+    }
+    if (!result.title || result.usedFallback) return
+
+    const chat = deps.store.requireChat(chatId)
+    if (chat.title !== expectedCurrentTitle) return
+
+    await deps.store.renameChat(chatId, result.title)
+    deps.emitStateChange(chatId)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    deps.reportBackgroundError?.(
+      `[title-generation] chat ${chatId} failed background title generation: ${message}`,
+    )
+  }
+}

package/src/server/claude-harness-stream.test.ts

@@ -0,0 +1,273 @@
+import { describe, expect, test } from "bun:test"
+import { createClaudeHarnessStream } from "./claude-harness-stream"
+import type { ClaudeRawSdkMessage } from "./claude-message-normalizer"
+import type { HarnessEvent } from "./harness-types"
+import type { ModelPrice } from "../shared/token-pricing"
+
+function fakeQuery(messages: unknown[]): AsyncGenerator<ClaudeRawSdkMessage> {
+  return (async function* () {
+    for (const m of messages) yield m as ClaudeRawSdkMessage
+  })()
+}
+
+async function collect(
+  messages: unknown[],
+  configuredContextWindow?: number,
+  resolveTurnPrice?: () => ModelPrice | null,
+): Promise<HarnessEvent[]> {
+  const events: HarnessEvent[] = []
+  for await (const ev of createClaudeHarnessStream(
+    fakeQuery(messages),
+    configuredContextWindow,
+    resolveTurnPrice,
+  )) {
+    events.push(ev)
+  }
+  return events
+}
+
+describe("createClaudeHarnessStream", () => {
+  test("empty stream yields nothing", async () => {
+    const events = await collect([])
+    expect(events).toHaveLength(0)
+  })
+
+  test("session_token event emitted when sdkMessage.session_id is present", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-abc",
+        message: { id: "m1", role: "assistant", content: [] },
+      },
+    ])
+    const tokens = events.filter((e) => e.type === "session_token")
+    expect(tokens).toHaveLength(1)
+    expect(tokens[0]).toEqual({ type: "session_token", sessionToken: "sess-abc" })
+  })
+
+  test("no session_token event when session_id is absent", async () => {
+    const events = await collect([
+      {
+        type: "result",
+        subtype: "success",
+        is_error: false,
+        duration_ms: 0,
+        uuid: "r1",
+      },
+    ])
+    const tokens = events.filter((e) => e.type === "session_token")
+    expect(tokens).toHaveLength(0)
+  })
+
+  test("rate_limit_event with resetsAt produces rate_limit HarnessEvent", async () => {
+    const resetAt = 1_748_800_000
+    const events = await collect([
+      {
+        type: "rate_limit_event",
+        session_id: "sess-rl",
+        rate_limit_info: { status: "rejected", resetsAt: resetAt },
+      },
+    ])
+    const rateLimits = events.filter((e) => e.type === "rate_limit")
+    expect(rateLimits).toHaveLength(1)
+    const ev = rateLimits[0]
+    expect(ev.type).toBe("rate_limit")
+    // SDK emits resetsAt as epoch seconds; limit-detector converts to ms
+    expect(ev.rateLimit?.resetAt).toBe(resetAt * 1000)
+  })
+
+  test("assistant message emits context_window_updated transcript entry", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-1",
+        message: { id: "m1", role: "assistant", content: [{ type: "text", text: "hello" }] },
+        usage: { input_tokens: 100, output_tokens: 30 },
+      },
+    ])
+    const cwUpdated = events.filter(
+      (e) => e.type === "transcript" && e.entry?.kind === "context_window_updated",
+    )
+    expect(cwUpdated.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test("result message produces enriched result entry with usage", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-u",
+        message: { id: "m1", role: "assistant", content: [] },
+        usage: { input_tokens: 50, output_tokens: 20 },
+      },
+      {
+        type: "result",
+        subtype: "success",
+        session_id: "sess-u",
+        is_error: false,
+        duration_ms: 300,
+        usage: { input_tokens: 50, output_tokens: 20 },
+        uuid: "r1",
+      },
+    ])
+    const resultEntries = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "result" ? [e.entry] : [],
+    )
+    expect(resultEntries).toHaveLength(1)
+    expect(resultEntries[0].usage).toBeDefined()
+  })
+
+  test("api_error in turn scrubs result body (no duplicate text)", async () => {
+    const errorText = "You've hit your limit"
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-ae",
+        uuid: "msg-err",
+        isApiErrorMessage: true,
+        message: {
+          model: "<synthetic>",
+          content: [{ type: "text", text: errorText }],
+        },
+      },
+      {
+        type: "result",
+        subtype: "error",
+        session_id: "sess-ae",
+        is_error: true,
+        result: errorText,
+        duration_ms: 1000,
+        uuid: "r-ae",
+      },
+    ])
+    const apiErrorEntries = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "api_error" ? [e.entry] : [],
+    )
+    const resultEntries = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "result" ? [e.entry] : [],
+    )
+    expect(apiErrorEntries).toHaveLength(1)
+    expect(resultEntries).toHaveLength(1)
+    // Result body is scrubbed to "" to avoid duplicate display
+    expect(resultEntries[0].result).toBe("")
+  })
+
+  test("normalizeClaudeStreamMessage entries are yielded as transcript events", async () => {
+    const events = await collect([
+      {
+        type: "result",
+        subtype: "success",
+        session_id: "sess-norm",
+        is_error: false,
+        result: "done",
+        duration_ms: 50,
+        uuid: "r-norm",
+      },
+    ])
+    const transcriptEntries = events.filter((e) => e.type === "transcript")
+    expect(transcriptEntries.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test("result with total_cost_usd attaches costUsd to result entry", async () => {
+    const events = await collect([
+      {
+        type: "result",
+        subtype: "success",
+        session_id: "sess-cost",
+        is_error: false,
+        duration_ms: 100,
+        total_cost_usd: 0.0042,
+        uuid: "r-cost",
+      },
+    ])
+    const resultEntries = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "result" ? [e.entry] : [],
+    )
+    expect(resultEntries).toHaveLength(1)
+    expect(resultEntries[0].costUsd).toBe(0.0042)
+  })
+
+  test("resolveTurnPrice callback used when total_cost_usd absent", async () => {
+    const price: ModelPrice = { inputPerMTok: 3, outputPerMTok: 15, cachedInputPerMTok: 0.3 }
+    const events = await collect(
+      [
+        {
+          type: "assistant",
+          session_id: "sess-price",
+          message: { id: "m1", role: "assistant", content: [] },
+          usage: { input_tokens: 1000, output_tokens: 100 },
+        },
+        {
+          type: "result",
+          subtype: "success",
+          session_id: "sess-price",
+          is_error: false,
+          duration_ms: 100,
+          usage: { input_tokens: 1000, output_tokens: 100 },
+          uuid: "r-price",
+        },
+      ],
+      undefined,
+      () => price,
+    )
+    const resultEntries = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "result" ? [e.entry] : [],
+    )
+    expect(resultEntries).toHaveLength(1)
+    expect(typeof resultEntries[0].costUsd).toBe("number")
+    expect((resultEntries[0].costUsd as number)).toBeGreaterThan(0)
+  })
+
+  test("duplicate assistant usage id is not double-counted", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-dup",
+        message: { id: "dup-id", role: "assistant", content: [] },
+        usage: { input_tokens: 10, output_tokens: 5 },
+      },
+      {
+        type: "assistant",
+        session_id: "sess-dup",
+        message: { id: "dup-id", role: "assistant", content: [] },
+        usage: { input_tokens: 10, output_tokens: 5 },
+      },
+    ])
+    const cwUpdated = events.filter(
+      (e) => e.type === "transcript" && e.entry?.kind === "context_window_updated",
+    )
+    // Only one context_window_updated per unique usage id
+    expect(cwUpdated).toHaveLength(1)
+  })
+
+  test("configuredContextWindow floors the context window from SDK", async () => {
+    const events = await collect(
+      [
+        {
+          type: "assistant",
+          session_id: "sess-1m",
+          message: { id: "m1", role: "assistant", content: [] },
+          usage: { input_tokens: 100, output_tokens: 50 },
+        },
+        {
+          type: "result",
+          subtype: "success",
+          session_id: "sess-1m",
+          is_error: false,
+          duration_ms: 100,
+          usage: { input_tokens: 100, output_tokens: 50 },
+          modelUsage: { "claude-sonnet-4-6": { contextWindow: 200_000 } },
+          uuid: "r-1m",
+        },
+      ],
+      1_000_000,
+    )
+    const cwUpdated = events.flatMap((e) =>
+      e.type === "transcript" && e.entry?.kind === "context_window_updated" ? [e.entry] : [],
+    )
+    // The configuredContextWindow (1M) should prevail over modelUsage (200K)
+    const lastSnapshot = cwUpdated[cwUpdated.length - 1]
+    expect(lastSnapshot).toBeDefined()
+    // maxTokens in the snapshot should reflect the 1M floor, not the 200K from modelUsage
+    expect(lastSnapshot.usage.maxTokens).toBeGreaterThanOrEqual(1_000_000)
+  })
+})

package/src/server/claude-harness-stream.ts

@@ -0,0 +1,158 @@
+import type { ContextWindowUsageSnapshot, ProviderUsage } from "../shared/types"
+import { computeCostUsd } from "../shared/token-pricing"
+import type { ModelPrice } from "../shared/token-pricing"
+import type { HarnessEvent } from "./harness-types"
+import {
+  timestamped,
+  type ClaudeRawSdkMessage,
+  getClaudeAssistantMessageUsageId,
+  normalizeClaudeStreamMessage,
+} from "./claude-message-normalizer"
+import {
+  normalizeClaudeUsageSnapshot,
+  resolveFinalTurnUsage,
+  maxClaudeContextWindowFromModelUsage,
+} from "./claude-usage-math"
+import { ClaudeLimitDetector } from "./auto-continue/limit-detector"
+
+export async function* createClaudeHarnessStream(
+  q: AsyncIterable<ClaudeRawSdkMessage>,
+  configuredContextWindow?: number,
+  resolveTurnPrice?: () => ModelPrice | null,
+): AsyncGenerator<HarnessEvent> {
+  let seenAssistantUsageIds = new Set<string>()
+  let latestUsageSnapshot: ContextWindowUsageSnapshot | null = null
+  let lastKnownContextWindow: number | undefined = configuredContextWindow
+  const detector = new ClaudeLimitDetector()
+  // SDK rate-limit / api-error turns emit BOTH a synthetic assistant
+  // `isApiErrorMessage` (→ `api_error` entry, red card with text) AND a
+  // `type:"result"` whose `result` field repeats the same text (→ second
+  // red card + "Failed after Xs"). Track per-turn api_error emission so
+  // we can scrub the duplicate body off the trailing result entry; the
+  // duration footer still renders, the message renders once.
+  let apiErrorEmittedInTurn = false
+
+  // Per-turn billed token usage and cost to attach to the result entry.
+  // Set when the `type:"result"` SDK message is processed; cleared after
+  // the result entry is yielded so they don't leak to a subsequent turn.
+  let pendingResultUsage: ProviderUsage | undefined
+  let pendingResultCost: number | undefined
+
+  for await (const sdkMessage of q) {
+    const sessionToken = typeof sdkMessage.session_id === "string" ? sdkMessage.session_id : null
+    if (sessionToken) {
+      yield { type: "session_token", sessionToken }
+    }
+
+    if (sdkMessage?.type === "rate_limit_event") {
+      const detection = detector.detectFromSdkRateLimitInfo("", sdkMessage.rate_limit_info)
+      if (detection) {
+        yield { type: "rate_limit", rateLimit: { resetAt: detection.resetAt, tz: detection.tz } }
+      }
+    }
+
+    if (sdkMessage?.type === "assistant") {
+      const usageId = getClaudeAssistantMessageUsageId(sdkMessage)
+      const usageSnapshot = normalizeClaudeUsageSnapshot(sdkMessage.usage, lastKnownContextWindow)
+      if (usageId && usageSnapshot && !seenAssistantUsageIds.has(usageId)) {
+        seenAssistantUsageIds.add(usageId)
+        latestUsageSnapshot = usageSnapshot
+        yield {
+          type: "transcript",
+          entry: timestamped({
+            kind: "context_window_updated",
+            usage: usageSnapshot,
+          }),
+        }
+      }
+    }
+
+    if (sdkMessage?.type === "result") {
+      const resultContextWindow = maxClaudeContextWindowFromModelUsage(sdkMessage.modelUsage)
+      // Never let SDK lower the configured window — see comment on
+      // parseConfiguredContextWindowFromModelId for the 1M beta footgun.
+      if (resultContextWindow !== undefined) {
+        lastKnownContextWindow = Math.max(lastKnownContextWindow ?? 0, resultContextWindow)
+      }
+
+      const accumulatedUsage = normalizeClaudeUsageSnapshot(
+        sdkMessage.usage,
+        lastKnownContextWindow,
+      )
+      const finalUsage = resolveFinalTurnUsage(
+        latestUsageSnapshot,
+        accumulatedUsage,
+        lastKnownContextWindow,
+      )
+
+      const providerCostUsd =
+        typeof sdkMessage.total_cost_usd === "number"
+          ? sdkMessage.total_cost_usd
+          : undefined
+
+      let costUsd = providerCostUsd
+      if (costUsd === undefined && resolveTurnPrice && finalUsage) {
+        const price = resolveTurnPrice()
+        if (price) {
+          costUsd = computeCostUsd(
+            {
+              inputTokens: finalUsage.inputTokens,
+              cachedInputTokens: finalUsage.cachedInputTokens,
+              outputTokens: finalUsage.outputTokens,
+            },
+            price,
+          )
+        }
+      }
+
+      // Stash billed token figures for the result entry (populated below
+      // in the entry loop). Prefer `accumulatedUsage` (the per-turn
+      // cumulative that the SDK computes) for tokens; fall back to
+      // `finalUsage` when accumulated is null.
+      const billed = accumulatedUsage ?? finalUsage
+      pendingResultUsage = billed
+        ? {
+            ...(billed.inputTokens !== undefined ? { inputTokens: billed.inputTokens } : {}),
+            ...(billed.outputTokens !== undefined ? { outputTokens: billed.outputTokens } : {}),
+            ...(billed.cachedInputTokens !== undefined ? { cachedInputTokens: billed.cachedInputTokens } : {}),
+          }
+        : undefined
+      pendingResultCost = costUsd
+
+      if (finalUsage) {
+        const usageWithCost = costUsd !== undefined ? { ...finalUsage, costUsd } : finalUsage
+        yield {
+          type: "transcript",
+          entry: timestamped({
+            kind: "context_window_updated",
+            usage: usageWithCost,
+          }),
+        }
+      }
+
+      seenAssistantUsageIds = new Set<string>()
+      latestUsageSnapshot = null
+    }
+
+    for (const entry of normalizeClaudeStreamMessage(sdkMessage)) {
+      if (entry.kind === "api_error") {
+        apiErrorEmittedInTurn = true
+      } else if (entry.kind === "result") {
+        const scrubbed = entry.isError && apiErrorEmittedInTurn
+          ? { ...entry, result: "" }
+          : entry
+        apiErrorEmittedInTurn = false
+        const enriched = {
+          ...scrubbed,
+          ...(pendingResultUsage !== undefined ? { usage: pendingResultUsage } : {}),
+          ...(pendingResultCost !== undefined ? { costUsd: pendingResultCost } : {}),
+        }
+        pendingResultUsage = undefined
+        pendingResultCost = undefined
+        yield { type: "transcript", entry: enriched }
+        continue
+      }
+      yield { type: "transcript", entry }
+    }
+  }
+}