@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@puredesktop/puredesktop-ui-bridge",
+  "version": "1.0.0-beta.1",
+  "description": "PureScience plugin SDK — bridge client, theme, and shared UI",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nikau-Dev/ps-suite.git",
+    "directory": "packages/ui"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./bridge/client": "./src/bridge/client.mjs",
+    "./bridge/events": "./src/bridge/events.mjs",
+    "./bridge/methods": "./src/bridge/methods.mjs",
+    "./bridge/react/usePlatformBridge": "./src/bridge/react/usePlatformBridge.tsx",
+    "./bridge/react/useIpc": "./src/bridge/react/useIpc.tsx",
+    "./bridge/react/usePlatformViewportResource": "./src/bridge/react/usePlatformViewportResource.tsx",
+    "./bridge/react/usePlatformThemeFromBridge": "./src/bridge/react/usePlatformThemeFromBridge.tsx",
+    "./bridge/react/usePlatformFilePreview": "./src/bridge/react/usePlatformFilePreview.tsx",
+    "./bridge/react/usePlatformFileBinaryDataUrl": "./src/bridge/react/usePlatformFileBinaryDataUrl.tsx",
+    "./bridge/fs": "./src/bridge/fs.ts",
+    "./bridge/collectionAssets": "./src/bridge/collectionAssets.ts",
+    "./bridge/collectionDocumentHtml": "./src/bridge/collectionDocumentHtml.ts",
+    "./bridge/collectionAssetAdapter": "./src/bridge/collectionAssetAdapter.ts",
+    "./bridge/inlinePreview": "./src/bridge/inlinePreview.ts",
+    "./bridge/render": "./src/bridge/render.ts",
+    "./bridge/pureRender": "./src/bridge/pureRender/index.ts",
+    "./bridge/watch": "./src/bridge/watch.ts",
+    "./bridge/agents": "./src/bridge/agents.ts",
+    "./bridge/agentToolHelpers": "./src/bridge/agentToolHelpers.ts",
+    "./bridge/react/usePlatformAgentTools": "./src/bridge/react/usePlatformAgentTools.tsx",
+    "./bridge/credentials": "./src/bridge/credentials.mjs",
+    "./bridge/context": "./src/bridge/context.mjs",
+    "./bridge/window": "./src/bridge/window.mjs",
+    "./bridge/screenAnnotation": "./src/bridge/screenAnnotation.ts",
+    "./bridge/react/usePlatformAgentSessions": "./src/bridge/react/usePlatformAgentSessions.tsx",
+    "./bridge/react/usePlatformAgentSessionDrive": "./src/bridge/react/usePlatformAgentSessionDrive.tsx",
+    "./bridge/react/usePlatformAgentRunLiveState": "./src/bridge/react/usePlatformAgentRunLiveState.tsx",
+    "./agents/runtime": "./src/agents/runtime/index.ts",
+    "./bridge/printDocument": "./src/bridge/printDocument.ts",
+    "./bridge/assets": "./src/bridge/assets.mjs",
+    "./bridge/dialog": "./src/bridge/dialog.mjs",
+    "./bridge/os": "./src/bridge/os.mjs",
+    "./components/credentials/CredentialsPanel": "./src/components/credentials/CredentialsPanel.tsx",
+    "./components/agents": "./src/components/agents/index.ts",
+    "./components/agent-feedback": "./src/components/agent-feedback/index.ts",
+    "./components/accessibility": "./src/components/accessibility/index.ts",
+    "./components/proofing": "./src/components/proofing/index.ts",
+    "./components/print-design": "./src/components/print-design/index.ts",
+    "./components/assets/asset-library": "./src/components/assets/asset-library/index.ts",
+    "./components/common/connections": "./src/components/common/connections/index.ts",
+    "./components/common/context": "./src/components/common/context/index.ts",
+    "./components/common/canvas": "./src/components/common/canvas/index.ts",
+    "./components/common/desk": "./src/components/common/desk/index.ts",
+    "./components/common/research": "./src/components/common/research/index.ts",
+    "./components/common/inputs/PaletteCirclePicker": "./src/components/common/inputs/PaletteCirclePicker.tsx",
+    "./components/common/inputs/PaletteDropdown": "./src/components/common/inputs/PaletteDropdown.tsx",
+    "./components/common/lists/reorderable": "./src/components/common/lists/reorderable/index.ts",
+    "./editor": "./src/editor/index.ts",
+    "./writing": "./src/writing/index.ts",
+    "./*": "./src/*"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@ant-design/icons": "^6.0.0",
+    "d3": "^7.9.0",
+    "katex": "^0.16.22",
+    "lucide-react": "^0.511.0",
+    "mermaid": "^11.15.0",
+    "styled-components": "^6.1.18",
+    "@puredesktop/platform-editor": "1.0.0-beta.1"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/d3": "^7.4.3",
+    "@types/react": "^19.1.6",
+    "happy-dom": "^20.0.10",
+    "react": "^19.1.0",
+    "vitest": "^3.2.4"
+  }
+}

package/src/agents/runtime/agentLiveReducer.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest'
+import { AgentLivePhase } from '../../components/agents/agentTypes.js'
+import { AgentRunEventType } from './agentRunEventTypes.js'
+import { createIdleLiveTurn, reduceAgentLiveTurn } from './agentLiveReducer.js'
+
+describe('reduceAgentLiveTurn', () => {
+  it('accumulates thinking and text deltas', () => {
+    let state = createIdleLiveTurn()
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TurnStarted,
+      runId: 'run-1',
+      seq: 1,
+      turn: 1,
+    })
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ThinkingDelta,
+      runId: 'run-1',
+      seq: 2,
+      delta: 'hmm',
+    })
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TextDelta,
+      runId: 'run-1',
+      seq: 3,
+      delta: 'Hi',
+    })
+
+    expect(state.phase).toBe(AgentLivePhase.Responding)
+    expect(state.thinking).toBe('hmm')
+    expect(state.text).toBe('Hi')
+  })
+
+  it('enters tools pending when a turn ends with tool calls', () => {
+    const state = reduceAgentLiveTurn(createIdleLiveTurn(), {
+      type: AgentRunEventType.TurnEnded,
+      runId: 'run-1',
+      seq: 1,
+      toolCallCount: 2,
+    })
+    expect(state.phase).toBe(AgentLivePhase.ToolsPending)
+  })
+
+  it('tracks context compaction from run events', () => {
+    let state = createIdleLiveTurn()
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ContextCompactionStarted,
+      runId: 'run-1',
+      seq: 1,
+      archivedMessageCount: 4,
+    })
+    expect(state.contextCompaction).toBe('summarizing')
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.ContextCompactionCompleted,
+      runId: 'run-1',
+      seq: 2,
+      activeFromIndex: 8,
+      summaryChars: 1200,
+    })
+    expect(state.contextCompaction).toBe('summarized')
+
+    state = reduceAgentLiveTurn(state, {
+      type: AgentRunEventType.TurnStarted,
+      runId: 'run-1',
+      seq: 3,
+      turn: 1,
+    })
+    expect(state.contextCompaction).toBeUndefined()
+    expect(state.phase).toBe(AgentLivePhase.Thinking)
+  })
+})

package/src/agents/runtime/agentLiveReducer.ts

@@ -0,0 +1,139 @@
+import {
+  AgentLivePhase,
+  type AgentLiveTurn,
+  type AgentUiToolCall,
+} from '../../components/agents/agentTypes.js'
+import {
+  AgentRunEventType,
+  type PlatformAgentRunEventPayload,
+} from './agentRunEventTypes.js'
+
+export function createIdleLiveTurn(): AgentLiveTurn {
+  return {
+    phase: AgentLivePhase.Idle,
+    thinking: '',
+    text: '',
+    toolCalls: [],
+  }
+}
+
+export function reduceAgentLiveTurn(
+  state: AgentLiveTurn,
+  event: PlatformAgentRunEventPayload,
+): AgentLiveTurn {
+  switch (event.type) {
+    case AgentRunEventType.TurnStarted:
+      return {
+        phase: AgentLivePhase.Thinking,
+        thinking: '',
+        text: '',
+        toolCalls: [],
+      }
+
+    case AgentRunEventType.ThinkingDelta:
+      return {
+        ...state,
+        phase: AgentLivePhase.Thinking,
+        thinking: state.thinking + event.delta,
+      }
+
+    case AgentRunEventType.TextDelta:
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        text: state.text + event.delta,
+      }
+
+    case AgentRunEventType.ToolCallStarted: {
+      const toolCalls = upsertToolCall(state.toolCalls, {
+        id: event.toolCallId,
+        name: event.name,
+        arguments: {},
+      })
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        toolCalls,
+      }
+    }
+
+    case AgentRunEventType.ToolCallArgsDelta:
+      return state
+
+    case AgentRunEventType.ToolCallDone:
+      return {
+        ...state,
+        toolCalls: upsertToolCall(state.toolCalls, event.toolCall),
+      }
+
+    case AgentRunEventType.ToolExecStarted:
+      return {
+        ...state,
+        phase: AgentLivePhase.ToolRunning,
+        activeTool: {
+          toolCallId: event.toolCallId,
+          name: event.name,
+          arguments: event.arguments,
+        },
+      }
+
+    case AgentRunEventType.ToolExecEnded:
+      return {
+        ...state,
+        phase: AgentLivePhase.Responding,
+        activeTool: undefined,
+      }
+
+    case AgentRunEventType.TurnEnded:
+      return event.toolCallCount > 0
+        ? {
+            ...state,
+            phase: AgentLivePhase.ToolsPending,
+            activeTool: undefined,
+          }
+        : {
+            ...state,
+            phase: AgentLivePhase.Idle,
+            activeTool: undefined,
+          }
+
+    case AgentRunEventType.ContextCompactionStarted:
+      return { ...state, contextCompaction: 'summarizing' }
+
+    case AgentRunEventType.ContextCompactionCompleted:
+      return { ...state, contextCompaction: 'summarized' }
+
+    case AgentRunEventType.StateChanged:
+      if (event.state === 'pending_tools') {
+        return {
+          ...state,
+          phase: AgentLivePhase.ToolsPending,
+          activeTool: undefined,
+        }
+      }
+      if (event.state === 'awaiting_user' || event.state === 'ready') {
+        return createIdleLiveTurn()
+      }
+      if (event.state === 'interrupted' || event.state === 'failed') {
+        return createIdleLiveTurn()
+      }
+      return state
+
+    case AgentRunEventType.Error:
+      return createIdleLiveTurn()
+
+    default:
+      return state
+  }
+}
+
+function upsertToolCall(
+  toolCalls: AgentUiToolCall[],
+  next: AgentUiToolCall,
+): AgentUiToolCall[] {
+  const index = toolCalls.findIndex(call => call.id === next.id)
+  if (index < 0) return [...toolCalls, next]
+  const copy = [...toolCalls]
+  copy[index] = { ...copy[index], ...next }
+  return copy
+}

package/src/agents/runtime/agentRunEventTypes.ts

@@ -0,0 +1,115 @@
+import type { PlatformAgentMessage } from '../../bridge/agentTypes.js'
+import type { PlatformAgentRunUsage } from '../../bridge/agentTypes.js'
+import type { AgentUiRunState } from '../../components/agents/agentTypes.js'
+import type { AgentUiToolCall } from '../../components/agents/agentTypes.js'
+
+/** Vendor-agnostic run events — matches main → shell streaming payloads. */
+export const AgentRunEventType = {
+  TurnStarted: 'turn_started',
+  ThinkingDelta: 'thinking_delta',
+  TextDelta: 'text_delta',
+  ToolCallStarted: 'tool_call_started',
+  ToolCallArgsDelta: 'tool_call_args_delta',
+  ToolCallDone: 'tool_call_done',
+  TurnEnded: 'turn_ended',
+  ToolExecStarted: 'tool_exec_started',
+  ToolExecEnded: 'tool_exec_ended',
+  StateChanged: 'state_changed',
+  UsageUpdated: 'usage_updated',
+  ContextCompactionStarted: 'context_compaction_started',
+  ContextCompactionCompleted: 'context_compaction_completed',
+  Error: 'error',
+} as const
+
+export type AgentRunEventTypeName =
+  (typeof AgentRunEventType)[keyof typeof AgentRunEventType]
+
+export interface AgentUsageTurnDelta {
+  inputTokens: number
+  outputTokens: number
+  totalTokens?: number
+}
+
+interface AgentRunEventBase {
+  runId: string
+  seq: number
+  type: string
+}
+
+export interface PlatformAgentRunSnapshotEvent {
+  runId: string
+  state: AgentUiRunState
+  turn: number
+  messages: PlatformAgentMessage[]
+  error?: string
+  interruptedReason?: string
+  effectiveModelId?: string
+  routingTier?: 'low' | 'high'
+  usage?: PlatformAgentRunUsage
+}
+
+/** Bridge + shell IPC event payloads consumed by the live reducer. */
+export type PlatformAgentRunEventPayload =
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.TurnStarted
+      turn: number
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ThinkingDelta
+      delta: string
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.TextDelta
+      delta: string
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ToolCallStarted
+      toolCallId: string
+      name: string
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ToolCallArgsDelta
+      toolCallId: string
+      delta: string
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ToolCallDone
+      toolCall: AgentUiToolCall
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.TurnEnded
+      toolCallCount: number
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.UsageUpdated
+      usage: AgentUsageTurnDelta
+      estimated?: boolean
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ContextCompactionStarted
+      archivedMessageCount: number
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ContextCompactionCompleted
+      activeFromIndex: number
+      summaryChars: number
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ToolExecStarted
+      toolCallId: string
+      name: string
+      arguments: Record<string, unknown>
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.ToolExecEnded
+      result?: { toolCallId?: string; content?: string }
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.StateChanged
+      state: AgentUiRunState
+      snapshot: PlatformAgentRunSnapshotEvent
+    })
+  | (AgentRunEventBase & {
+      type: typeof AgentRunEventType.Error
+      message: string
+    })

package/src/agents/runtime/contextWindowUsage.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import {
+  contextUsagePercent,
+  withContextWindowUsage,
+} from './contextWindowUsage.js'
+
+describe('contextWindowUsage', () => {
+  it('attaches catalog context window to usage', () => {
+    expect(
+      withContextWindowUsage(
+        { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
+        1_000_000,
+      ),
+    ).toEqual({
+      inputTokens: 1,
+      outputTokens: 2,
+      totalTokens: 3,
+      contextWindowTokens: 1_000_000,
+    })
+  })
+
+  it('computes usage percent capped at 100', () => {
+    expect(
+      contextUsagePercent({
+        totalTokens: 50_000,
+        contextFillTokens: 50_000,
+        contextWindowTokens: 1_000_000,
+      }),
+    ).toBe(5)
+    expect(
+      contextUsagePercent({
+        totalTokens: 2_000_000,
+        contextFillTokens: 950_000,
+        contextWindowTokens: 1_000_000,
+      }),
+    ).toBe(95)
+  })
+})

package/src/agents/runtime/contextWindowUsage.ts

@@ -0,0 +1,25 @@
+import type { PlatformAgentRunUsage } from '../../bridge/agentTypes.js'
+
+export function withContextWindowUsage(
+  usage: PlatformAgentRunUsage | undefined,
+  contextWindowTokens: number | undefined,
+): PlatformAgentRunUsage | undefined {
+  if (!usage) return undefined
+  if (!contextWindowTokens) return usage
+  return { ...usage, contextWindowTokens }
+}
+
+/** 0–100 when a context window is known; otherwise undefined. */
+export function contextUsagePercent(
+  usage: Pick<
+    PlatformAgentRunUsage,
+    'totalTokens' | 'contextWindowTokens' | 'contextFillTokens'
+  >,
+): number | undefined {
+  const { contextWindowTokens } = usage
+  const fill = usage.contextFillTokens ?? usage.totalTokens
+  if (!contextWindowTokens || contextWindowTokens <= 0 || fill <= 0) {
+    return undefined
+  }
+  return Math.min(100, Math.round((fill / contextWindowTokens) * 100))
+}

package/src/agents/runtime/index.ts

@@ -0,0 +1,24 @@
+export {
+  AgentRunEventType,
+  type AgentRunEventTypeName,
+  type AgentUsageTurnDelta,
+  type PlatformAgentRunEventPayload,
+  type PlatformAgentRunSnapshotEvent,
+} from './agentRunEventTypes.js'
+export { createIdleLiveTurn, reduceAgentLiveTurn } from './agentLiveReducer.js'
+export { unresolvedToolCalls } from './unresolvedToolCalls.js'
+export { derivePendingToolCalls } from './pendingToolCalls.js'
+export { toolRequiresApproval } from './toolRequiresApproval.js'
+export { mergeUsageTurn } from './mergeUsageTurn.js'
+export {
+  contextUsagePercent,
+  withContextWindowUsage,
+} from './contextWindowUsage.js'
+export {
+  isComposerEnabled,
+  mapApprovalPendingToolCalls,
+  mapPendingToolCalls,
+  mapRunState,
+  mapSnapshotToMessages,
+} from './mapAgentSnapshot.js'
+export { mapAgentMessages } from './mapAgentMessages.js'

package/src/agents/runtime/mapAgentMessages.ts

@@ -0,0 +1,54 @@
+import type { PlatformAgentRunSnapshot } from '../../bridge/agentTypes.js'
+import {
+  AgentLivePhase,
+  type AgentLiveTurn,
+  type AgentUiMessage,
+} from '../../components/agents/agentTypes.js'
+import { mapSnapshotToMessages } from './mapAgentSnapshot.js'
+
+export function mapAgentMessages(
+  snapshot: PlatformAgentRunSnapshot | null,
+  liveTurn: AgentLiveTurn | null,
+): AgentUiMessage[] {
+  const committed = mapSnapshotToMessages(snapshot)
+  if (!liveTurn || liveTurn.phase === AgentLivePhase.Idle) {
+    return committed
+  }
+
+  if (
+    liveTurn.phase === AgentLivePhase.ToolsPending ||
+    liveTurn.phase === AgentLivePhase.ToolRunning
+  ) {
+    return committed
+  }
+
+  if (
+    liveTurn.phase === AgentLivePhase.Thinking &&
+    !liveTurn.text &&
+    liveTurn.toolCalls.length === 0
+  ) {
+    return [
+      ...committed,
+      {
+        id: 'live-assistant',
+        role: 'assistant',
+        content: '',
+        thinking: liveTurn.thinking,
+        streaming: true,
+      },
+    ]
+  }
+
+  return [
+    ...committed,
+    {
+      id: 'live-assistant',
+      role: 'assistant',
+      content: liveTurn.text,
+      thinking: liveTurn.thinking || undefined,
+      streaming: true,
+      toolCalls: liveTurn.toolCalls.length > 0 ? liveTurn.toolCalls : undefined,
+      activeTool: liveTurn.activeTool,
+    },
+  ]
+}

package/src/agents/runtime/mapAgentSnapshot.ts

@@ -0,0 +1,71 @@
+import type {
+  PlatformAgentRunSnapshot,
+  PlatformAgentSessionToolPolicy,
+} from '../../bridge/agentTypes.js'
+import {
+  AgentUiRunState,
+  type AgentUiMessage,
+  type AgentUiToolCall,
+} from '../../components/agents/agentTypes.js'
+import { derivePendingToolCalls } from './pendingToolCalls.js'
+import { toolRequiresApproval } from './toolRequiresApproval.js'
+
+const VISIBLE_ROLES = new Set(['user', 'assistant', 'tool'])
+
+export function mapRunState(state: string): typeof AgentUiRunState[keyof typeof AgentUiRunState] {
+  return state as typeof AgentUiRunState[keyof typeof AgentUiRunState]
+}
+
+export function mapSnapshotToMessages(
+  snapshot: PlatformAgentRunSnapshot | null,
+): AgentUiMessage[] {
+  if (!snapshot) return []
+
+  return snapshot.messages
+    .filter(message => VISIBLE_ROLES.has(message.role))
+    .map((message, index) => ({
+      id: `${message.role}-${index}-${message.toolCallId ?? 'msg'}`,
+      role: message.role as AgentUiMessage['role'],
+      content: message.content,
+      toolCalls: message.toolCalls?.map(mapToolCall),
+    }))
+}
+
+export function mapPendingToolCalls(
+  snapshot: PlatformAgentRunSnapshot | null,
+): AgentUiToolCall[] {
+  if (!snapshot) return []
+  return derivePendingToolCalls(snapshot.messages, snapshot.state).map(mapToolCall)
+}
+
+/** Pending tools that still need explicit user approval. */
+export function mapApprovalPendingToolCalls(
+  snapshot: PlatformAgentRunSnapshot | null,
+  policy: PlatformAgentSessionToolPolicy | undefined,
+): AgentUiToolCall[] {
+  if (!snapshot || !policy) return []
+  return derivePendingToolCalls(snapshot.messages, snapshot.state)
+    .filter(call => toolRequiresApproval(call.name, policy))
+    .map(mapToolCall)
+}
+
+function mapToolCall(call: AgentUiToolCall): AgentUiToolCall {
+  return {
+    id: call.id,
+    name: call.name,
+    arguments: call.arguments,
+  }
+}
+
+export function isComposerEnabled(
+  runState: typeof AgentUiRunState[keyof typeof AgentUiRunState] | null,
+  busy: boolean,
+): boolean {
+  if (busy) return false
+  return (
+    runState === null ||
+    runState === AgentUiRunState.AwaitingUser ||
+    runState === AgentUiRunState.Failed ||
+    runState === AgentUiRunState.Interrupted
+  )
+}

package/src/agents/runtime/mergeUsageTurn.ts

@@ -0,0 +1,23 @@
+import type { PlatformAgentRunUsage } from '../../bridge/agentTypes.js'
+import type { AgentUsageTurnDelta } from './agentRunEventTypes.js'
+
+export function mergeUsageTurn(
+  base: PlatformAgentRunUsage | undefined,
+  delta: AgentUsageTurnDelta,
+  estimated = false,
+): PlatformAgentRunUsage {
+  const turnTotal =
+    delta.totalTokens ?? delta.inputTokens + delta.outputTokens
+  const next: PlatformAgentRunUsage = {
+    inputTokens: (base?.inputTokens ?? 0) + delta.inputTokens,
+    outputTokens: (base?.outputTokens ?? 0) + delta.outputTokens,
+    totalTokens: (base?.totalTokens ?? 0) + turnTotal,
+    contextWindowTokens: base?.contextWindowTokens,
+    contextFillTokens: base?.contextFillTokens,
+    estimated: base?.estimated || estimated,
+  }
+  if (delta.inputTokens > 0) {
+    next.contextFillTokens = delta.inputTokens
+  }
+  return next
+}