repoburg 1.3.188 → 1.3.196

package/agent-pane/frontend/src/api/sessions.test.ts

@@ -0,0 +1,241 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock the client module to capture call signatures without network access
+vi.mock('./client.ts', () => ({
+  apiGet: vi.fn(),
+  apiPost: vi.fn(),
+  apiDelete: vi.fn(),
+  apiPatch: vi.fn(),
+}));
+
+import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
+import {
+  fetchSessions,
+  fetchSessionDetail,
+  createSession,
+  deleteSession,
+  submitPrompt,
+  cancelTurn,
+  renameSession,
+  markFinished,
+  reopenSession,
+  clearUnreviewed,
+  updateModelConfig,
+  rewindSession,
+  branchSession,
+} from './sessions.ts';
+import type { Session, SessionDetail, Turn } from '../types/index.ts';
+
+const NOW = '2025-01-01T00:00:00Z';
+
+function makeSession(overrides: Partial<Session> = {}): Session {
+  return {
+    id: 's1',
+    title: 'Test',
+    runtime_type: 'codex',
+    model: null,
+    model_reasoning_effort: null,
+    cwd: null,
+    external_thread_id: null,
+    status: 'active',
+    is_running: 0,
+    lifecycle: 'working',
+    has_unreviewed: 0,
+    runtime_config: null,
+    created_at: NOW,
+    updated_at: NOW,
+    ...overrides,
+  };
+}
+
+function makeTurn(overrides: Partial<Turn> = {}): Turn {
+  return {
+    id: 't1',
+    session_id: 's1',
+    user_prompt: 'test',
+    agent_response: null,
+    thoughts: null,
+    token_usage: null,
+    external_turn_id: null,
+    status: 'completed',
+    error: null,
+    created_at: NOW,
+    updated_at: NOW,
+    items: [],
+    ...overrides,
+  };
+}
+
+describe('fetchSessions', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiGet with /sessions', async () => {
+    const sessions = [makeSession()];
+    vi.mocked(apiGet).mockResolvedValue(sessions);
+    const result = await fetchSessions();
+    expect(apiGet).toHaveBeenCalledWith('/sessions');
+    expect(result).toEqual(sessions);
+  });
+});
+
+describe('fetchSessionDetail', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiGet with /sessions/:id', async () => {
+    const detail: SessionDetail = { ...makeSession(), turns: [] };
+    vi.mocked(apiGet).mockResolvedValue(detail);
+    const result = await fetchSessionDetail('s1');
+    expect(apiGet).toHaveBeenCalledWith('/sessions/s1');
+    expect(result).toEqual(detail);
+  });
+});
+
+describe('createSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with body', async () => {
+    const session = makeSession({ title: 'New' });
+    vi.mocked(apiPost).mockResolvedValue(session);
+    const result = await createSession({ title: 'New', model: 'gpt-5.6-sol' });
+    expect(apiPost).toHaveBeenCalledWith('/sessions', { title: 'New', model: 'gpt-5.6-sol' });
+    expect(result).toEqual(session);
+  });
+});
+
+describe('deleteSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiDelete with /sessions/:id', async () => {
+    vi.mocked(apiDelete).mockResolvedValue({ success: true });
+    const result = await deleteSession('s1');
+    expect(apiDelete).toHaveBeenCalledWith('/sessions/s1');
+    expect(result).toEqual({ success: true });
+  });
+});
+
+describe('submitPrompt', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with user_prompt body', async () => {
+    const turn = makeTurn({ user_prompt: 'hello' });
+    vi.mocked(apiPost).mockResolvedValue(turn);
+    const result = await submitPrompt('s1', 'hello');
+    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/turns', { user_prompt: 'hello' });
+    expect(result).toEqual(turn);
+  });
+});
+
+describe('cancelTurn', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with /sessions/:id/cancel', async () => {
+    vi.mocked(apiPost).mockResolvedValue({ success: true });
+    await cancelTurn('s1');
+    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/cancel');
+  });
+});
+
+describe('renameSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPatch with title body', async () => {
+    const session = makeSession({ title: 'Renamed' });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await renameSession('s1', 'Renamed');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { title: 'Renamed' });
+  });
+});
+
+describe('markFinished', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPatch with lifecycle finished', async () => {
+    const session = makeSession({ lifecycle: 'finished' });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await markFinished('s1');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { lifecycle: 'finished' });
+  });
+});
+
+describe('reopenSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPatch with lifecycle working', async () => {
+    const session = makeSession({ lifecycle: 'working' });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await reopenSession('s1');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { lifecycle: 'working' });
+  });
+});
+
+describe('clearUnreviewed', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPatch with has_unreviewed 0', async () => {
+    const session = makeSession({ has_unreviewed: 0 });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await clearUnreviewed('s1');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { has_unreviewed: 0 });
+  });
+});
+
+describe('updateModelConfig', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPatch with model and reasoning effort', async () => {
+    const session = makeSession({ model: 'gpt-5.6-sol', model_reasoning_effort: 'high' });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await updateModelConfig('s1', 'gpt-5.6-sol', 'high');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', {
+      model: 'gpt-5.6-sol',
+      model_reasoning_effort: 'high',
+    });
+  });
+
+  it('passes null model and effort', async () => {
+    const session = makeSession({ model: null, model_reasoning_effort: null });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await updateModelConfig('s1', null, null);
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { model: null, model_reasoning_effort: null });
+  });
+
+  it('includes runtime_type when provided', async () => {
+    const session = makeSession({ runtime_type: 'claude', model: null });
+    vi.mocked(apiPatch).mockResolvedValue(session);
+    await updateModelConfig('s1', null, null, 'claude');
+    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', {
+      model: null,
+      model_reasoning_effort: null,
+      runtime_type: 'claude',
+    });
+  });
+});
+
+describe('rewindSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with turn_id', async () => {
+    const session = makeSession({ external_thread_id: null });
+    vi.mocked(apiPost).mockResolvedValue(session);
+    await rewindSession('s1', 't1');
+    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/rewind', { turn_id: 't1' });
+  });
+});
+
+describe('branchSession', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with turn_id and title', async () => {
+    const session = makeSession({ id: 's2', title: 'Branch' });
+    vi.mocked(apiPost).mockResolvedValue(session);
+    await branchSession('s1', 't1', 'Branch');
+    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/branch', { turn_id: 't1', title: 'Branch' });
+  });
+
+  it('passes undefined title when not provided', async () => {
+    const session = makeSession({ id: 's2' });
+    vi.mocked(apiPost).mockResolvedValue(session);
+    await branchSession('s1', 't1');
+    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/branch', { turn_id: 't1', title: undefined });
+  });
+});

package/agent-pane/frontend/src/api/sessions.ts

@@ -1,47 +1,89 @@
 import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
 import type { Session, SessionDetail, Turn } from '../types/index.ts';
 
+/** Fetch all sessions, ordered by creation date (newest first). */
 export function fetchSessions(): Promise<Session[]> {
   return apiGet<Session[]>('/sessions');
 }
 
+/** Fetch a single session with all its turns and items. */
 export function fetchSessionDetail(id: string): Promise<SessionDetail> {
   return apiGet<SessionDetail>(`/sessions/${id}`);
 }
 
+/** Create a new session with optional title, model, and working directory. */
 export function createSession(body: {
   title?: string;
   runtime_type?: string;
   model?: string;
+  model_reasoning_effort?: string;
   cwd?: string;
+  runtime_config?: string;
 }): Promise<Session> {
   return apiPost<Session>('/sessions', body);
 }
 
+/** Delete a session and all its turns and items (cascade). */
 export function deleteSession(id: string): Promise<{ success: boolean }> {
   return apiDelete<{ success: boolean }>(`/sessions/${id}`);
 }
 
+/** Submit a user prompt to a session — starts a Codex turn (fire-and-forget). */
 export function submitPrompt(sessionId: string, userPrompt: string): Promise<Turn> {
   return apiPost<Turn>(`/sessions/${sessionId}/turns`, { user_prompt: userPrompt });
 }
 
+/** Cancel the currently running turn in a session. */
 export function cancelTurn(sessionId: string): Promise<{ success: boolean }> {
   return apiPost<{ success: boolean }>(`/sessions/${sessionId}/cancel`);
 }
 
+/** Rename a session by updating its title. */
 export function renameSession(sessionId: string, title: string): Promise<Session> {
   return apiPatch<Session>(`/sessions/${sessionId}`, { title });
 }
 
+/** Mark a session as finished (lifecycle = 'finished'). */
 export function markFinished(sessionId: string): Promise<Session> {
   return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'finished' });
 }
 
+/** Reopen a finished session (lifecycle = 'working'). */
 export function reopenSession(sessionId: string): Promise<Session> {
   return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'working' });
 }
 
+/** Clear the "has unreviewed" flag on a session (reviewed by user). */
 export function clearUnreviewed(sessionId: string): Promise<Session> {
   return apiPatch<Session>(`/sessions/${sessionId}`, { has_unreviewed: 0 });
-}
+}
+
+/** Update the model, reasoning effort, and/or provider for a session. Clears the cached thread when changed. */
+export function updateModelConfig(
+  sessionId: string,
+  model: string | null,
+  modelReasoningEffort: string | null,
+  runtimeType?: string,
+): Promise<Session> {
+  const body: Record<string, unknown> = { model, model_reasoning_effort: modelReasoningEffort };
+  if (runtimeType !== undefined) body.runtime_type = runtimeType;
+  return apiPatch<Session>(`/sessions/${sessionId}`, body);
+}
+
+/** Update the runtime config (sandbox mode, web search, network access) for a session. */
+export function updateRuntimeConfig(
+  sessionId: string,
+  runtimeConfig: string | null,
+): Promise<Session> {
+  return apiPatch<Session>(`/sessions/${sessionId}`, { runtime_config: runtimeConfig });
+}
+
+/** Rewind a session to a specific turn — deletes turns after the target, resets the Codex thread. */
+export function rewindSession(sessionId: string, turnId: string): Promise<Session> {
+  return apiPost<Session>(`/sessions/${sessionId}/rewind`, { turn_id: turnId });
+}
+
+/** Branch a session from a specific turn — creates a new session with turns up to and including the target. */
+export function branchSession(sessionId: string, turnId: string, title?: string): Promise<Session> {
+  return apiPost<Session>(`/sessions/${sessionId}/branch`, { turn_id: turnId, title });
+}

package/agent-pane/frontend/src/api/skills.ts

@@ -0,0 +1,12 @@
+import { apiGet } from './client.ts';
+import type { Extension } from '../types/index.ts';
+
+/** Fetch all available skills (user + system). */
+export function fetchSkills(): Promise<Extension[]> {
+  return apiGet<Extension[]>('/skills');
+}
+
+/** Fetch full SKILL.md content for a specific skill. */
+export function fetchSkillContent(name: string): Promise<{ name: string; content: string; path: string }> {
+  return apiGet(`/skills/${name}`);
+}

package/agent-pane/frontend/src/api/websocket.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { connectWebSocket, disconnectWebSocket } from './websocket.ts';
+import type { Item, TokenUsage } from '../types/index.ts';
+
+// Mock the store to capture state dispatches
+vi.mock('../store/store.ts', () => {
+  const handlers: Record<string, (...args: unknown[]) => void> = {};
+  return {
+    useStore: {
+      getState: () => handlers,
+      setState: vi.fn(),
+    },
+  };
+});
+
+// We need to dynamically set the handlers on the mock
+import { useStore } from '../store/store.ts';
+
+const NOW = '2025-01-01T00:00:00Z';
+
+// Type-safe accessor for the mock store state
+function getMockStore() {
+  return useStore.getState() as unknown as Record<string, ReturnType<typeof vi.fn>>;
+}
+
+// Reset the mock store to have all the actions as vi.fn()
+function setupMockStore() {
+  const store = getMockStore();
+  const actions = [
+    'setWsConnected',
+    'addLogEntry',
+    'refreshActiveSession',
+    'addToast',
+    'onTurnStarted',
+    'onItemStarted',
+    'onItemUpdated',
+    'onItemCompleted',
+    'onItemDelta',
+    'onTurnCompleted',
+    'onTokenUsageUpdated',
+    'onTurnFailed',
+    'onTurnCancelled',
+    'onSessionTitle',
+  ];
+  for (const action of actions) {
+    store[action] = vi.fn();
+  }
+}
+
+// Mock WebSocket class
+class MockWebSocket {
+  static instances: MockWebSocket[] = [];
+  static lastInstance: MockWebSocket | null = null;
+
+  static readonly OPEN = 1;
+  static readonly CONNECTING = 0;
+  static readonly CLOSED = 3;
+
+  readyState = MockWebSocket.CONNECTING;
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+
+  constructor(public url: string) {
+    MockWebSocket.instances.push(this);
+    MockWebSocket.lastInstance = this;
+  }
+
+  close() {
+    this.readyState = MockWebSocket.CLOSED;
+    if (this.onclose) this.onclose();
+  }
+}
+
+describe('connectWebSocket', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    MockWebSocket.instances = [];
+    MockWebSocket.lastInstance = null;
+    setupMockStore();
+    vi.stubGlobal('WebSocket', MockWebSocket);
+    // Reset module-level state by calling disconnect first
+    disconnectWebSocket();
+  });
+
+  afterEach(() => {
+    disconnectWebSocket();
+    vi.unstubAllGlobals();
+  });
+
+  it('creates a new WebSocket connection', () => {
+    connectWebSocket();
+    expect(MockWebSocket.lastInstance).not.toBeNull();
+    expect(MockWebSocket.lastInstance!.url).toContain('/ws');
+  });
+
+  it('does not create duplicate connection when already connecting', () => {
+    connectWebSocket();
+    connectWebSocket();
+    expect(MockWebSocket.instances).toHaveLength(1);
+  });
+
+  it('calls setWsConnected(true) and addLogEntry on open', () => {
+    connectWebSocket();
+    const ws = MockWebSocket.lastInstance!;
+    ws.readyState = MockWebSocket.OPEN;
+    ws.onopen!();
+
+    const store = getMockStore();
+    expect(store.setWsConnected).toHaveBeenCalledWith(true);
+    expect(store.addLogEntry).toHaveBeenCalledWith('INFO', 'WebSocket connected');
+  });
+
+  it('does not call refreshActiveSession on first connect', () => {
+    connectWebSocket();
+    const ws = MockWebSocket.lastInstance!;
+    ws.readyState = MockWebSocket.OPEN;
+    ws.onopen!();
+
+    const store = getMockStore();
+    expect(store.refreshActiveSession).not.toHaveBeenCalled();
+  });
+
+  it('calls setWsConnected(false) on close', () => {
+    connectWebSocket();
+    const ws = MockWebSocket.lastInstance!;
+    ws.onclose!();
+
+    const store = getMockStore();
+    expect(store.setWsConnected).toHaveBeenCalledWith(false);
+    expect(store.addLogEntry).toHaveBeenCalledWith('WARN', 'WebSocket disconnected');
+  });
+});
+
+describe('disconnectWebSocket', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    MockWebSocket.instances = [];
+    MockWebSocket.lastInstance = null;
+    setupMockStore();
+    vi.stubGlobal('WebSocket', MockWebSocket);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('closes existing connection and clears handlers', () => {
+    connectWebSocket();
+    const ws = MockWebSocket.lastInstance!;
+    const closeSpy = vi.spyOn(ws, 'close');
+
+    disconnectWebSocket();
+
+    expect(closeSpy).toHaveBeenCalled();
+    expect(ws.onclose).toBeNull(); // prevents reconnect on intentional close
+    const store = getMockStore();
+    expect(store.setWsConnected).toHaveBeenCalledWith(false);
+  });
+
+  it('does nothing when no connection exists', () => {
+    disconnectWebSocket();
+    // Should not throw
+    expect(MockWebSocket.instances).toHaveLength(0);
+  });
+});
+
+describe('WebSocket event dispatch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    MockWebSocket.instances = [];
+    MockWebSocket.lastInstance = null;
+    setupMockStore();
+    vi.stubGlobal('WebSocket', MockWebSocket);
+    connectWebSocket();
+  });
+
+  afterEach(() => {
+    disconnectWebSocket();
+    vi.unstubAllGlobals();
+  });
+
+  function sendMessage(data: unknown) {
+    const ws = MockWebSocket.lastInstance!;
+    ws.onmessage!({ data: JSON.stringify(data) });
+  }
+
+  it('dispatches turn:started event', () => {
+    sendMessage({ event: 'turn:started', data: { sessionId: 's1', turnId: 't1' } });
+    const store = getMockStore();
+    expect(store.onTurnStarted).toHaveBeenCalledWith('s1', 't1');
+  });
+
+  it('dispatches item:started event', () => {
+    const item: Item = {
+      id: 'i1', turn_id: 't1', external_item_id: 'e1', type: 'agent_message',
+      data: { text: 'hello' }, status: 'in_progress', created_at: NOW, updated_at: NOW,
+    };
+    sendMessage({ event: 'item:started', data: { sessionId: 's1', turnId: 't1', item } });
+    const store = getMockStore();
+    expect(store.onItemStarted).toHaveBeenCalledWith('s1', 't1', item);
+  });
+
+  it('dispatches item:updated event', () => {
+    const item: Item = {
+      id: 'i1', turn_id: 't1', external_item_id: 'e1', type: 'command_execution',
+      data: { command: 'ls' }, status: 'in_progress', created_at: NOW, updated_at: NOW,
+    };
+    sendMessage({ event: 'item:updated', data: { sessionId: 's1', turnId: 't1', item } });
+    const store = getMockStore();
+    expect(store.onItemUpdated).toHaveBeenCalledWith('s1', 't1', item);
+  });
+
+  it('dispatches item:completed event', () => {
+    const item: Item = {
+      id: 'i1', turn_id: 't1', external_item_id: 'e1', type: 'agent_message',
+      data: { text: 'done' }, status: 'completed', created_at: NOW, updated_at: NOW,
+    };
+    sendMessage({ event: 'item:completed', data: { sessionId: 's1', turnId: 't1', item } });
+    const store = getMockStore();
+    expect(store.onItemCompleted).toHaveBeenCalledWith('s1', 't1', item);
+  });
+
+  it('dispatches item:delta event', () => {
+    sendMessage({ event: 'item:delta', data: { sessionId: 's1', turnId: 't1', itemId: 'ext-i1', delta: 'Hello' } });
+    const store = getMockStore();
+    expect(store.onItemDelta).toHaveBeenCalledWith('s1', 't1', 'ext-i1', 'Hello');
+  });
+
+  it('dispatches turn:tokenUsage event', () => {
+    const usage: TokenUsage = {
+      input_tokens: 100, cached_input_tokens: 0, cache_write_input_tokens: 0,
+      output_tokens: 200, reasoning_output_tokens: 0,
+    };
+    sendMessage({ event: 'turn:tokenUsage', data: { sessionId: 's1', turnId: 't1', usage } });
+    const store = getMockStore();
+    expect(store.onTokenUsageUpdated).toHaveBeenCalledWith('s1', 't1', usage);
+  });
+
+  it('dispatches turn:completed event with usage', () => {
+    const usage: TokenUsage = {
+      input_tokens: 100, cached_input_tokens: 0, cache_write_input_tokens: 0,
+      output_tokens: 200, reasoning_output_tokens: 0,
+    };
+    sendMessage({ event: 'turn:completed', data: { sessionId: 's1', turnId: 't1', usage, hasUnreviewed: true } });
+    const store = getMockStore();
+    expect(store.onTurnCompleted).toHaveBeenCalledWith('s1', 't1', usage, true);
+  });
+
+  it('dispatches turn:completed event without usage (real app-server)', () => {
+    sendMessage({ event: 'turn:completed', data: { sessionId: 's1', turnId: 't1', hasUnreviewed: true } });
+    const store = getMockStore();
+    expect(store.onTurnCompleted).toHaveBeenCalledWith('s1', 't1', undefined, true);
+  });
+
+  it('dispatches turn:failed event with error', () => {
+    sendMessage({ event: 'turn:failed', data: { sessionId: 's1', turnId: 't1', error: 'crashed' } });
+    const store = getMockStore();
+    expect(store.onTurnFailed).toHaveBeenCalledWith('s1', 't1', 'crashed');
+  });
+
+  it('dispatches turn:cancelled event', () => {
+    sendMessage({ event: 'turn:cancelled', data: { sessionId: 's1', turnId: 't1' } });
+    const store = getMockStore();
+    expect(store.onTurnCancelled).toHaveBeenCalledWith('s1', 't1');
+  });
+
+  it('dispatches session:title event', () => {
+    sendMessage({ event: 'session:title', data: { sessionId: 's1', title: 'New Title' } });
+    const store = getMockStore();
+    expect(store.onSessionTitle).toHaveBeenCalledWith('s1', 'New Title');
+  });
+
+  it('ignores malformed JSON without error', () => {
+    const ws = MockWebSocket.lastInstance!;
+    // Should not throw
+    ws.onmessage!({ data: 'not json' });
+    const store = getMockStore();
+    expect(store.onTurnStarted).not.toHaveBeenCalled();
+  });
+
+  it('ignores unknown event types', () => {
+    sendMessage({ event: 'unknown:event', data: {} });
+    const store = getMockStore();
+    expect(store.onTurnStarted).not.toHaveBeenCalled();
+  });
+});

package/agent-pane/frontend/src/api/websocket.ts

@@ -102,10 +102,23 @@ interface ItemEventPayload {
 interface TurnCompletedPayload {
   sessionId: string;
   turnId: string;
-  usage: TokenUsage;
+  usage?: TokenUsage;
   hasUnreviewed?: boolean;
 }
 
+interface ItemDeltaPayload {
+  sessionId: string;
+  turnId: string;
+  itemId: string;
+  delta: string;
+}
+
+interface TokenUsageUpdatedPayload {
+  sessionId: string;
+  turnId: string;
+  usage: TokenUsage;
+}
+
 interface TurnFailedPayload {
   sessionId: string;
   turnId: string;
@@ -134,16 +147,28 @@ const HANDLERS: Record<string, WsEventHandler> = {
     const p = data as ItemEventPayload;
     useStore.getState().onItemCompleted(p.sessionId, p.turnId, p.item);
   },
+  'item:delta': (data) => {
+    const p = data as ItemDeltaPayload;
+    useStore.getState().onItemDelta(p.sessionId, p.turnId, p.itemId, p.delta);
+  },
   'turn:completed': (data) => {
     const p = data as TurnCompletedPayload;
     useStore.getState().onTurnCompleted(p.sessionId, p.turnId, p.usage, p.hasUnreviewed);
   },
+  'turn:tokenUsage': (data) => {
+    const p = data as TokenUsageUpdatedPayload;
+    useStore.getState().onTokenUsageUpdated(p.sessionId, p.turnId, p.usage);
+  },
   'turn:failed': (data) => {
     const p = data as TurnFailedPayload;
     useStore.getState().onTurnFailed(p.sessionId, p.turnId, p.error);
   },
+  'turn:cancelled': (data) => {
+    const p = data as TurnEventPayload;
+    useStore.getState().onTurnCancelled(p.sessionId, p.turnId);
+  },
   'session:title': (data) => {
     const p = data as SessionTitlePayload;
     useStore.getState().onSessionTitle(p.sessionId, p.title);
   },
-};
+};