@robota-sdk/agent-transport 3.0.0-beta.82 → 3.0.0-beta.84

package/src/__tests__/message-decoders.test.ts

@@ -1,3 +1,4 @@
+import { SESSION_CHANGE_REFUSAL_CODES } from '@robota-sdk/agent-interface-session';
 import { describe, expect, it } from 'vitest';
 
 import {
@@ -18,11 +19,27 @@ import type { TClientMessage, TServerMessage } from '../wire-messages.js';
  */
 const CLIENT_SAMPLES: Readonly<Record<TClientMessage['type'], TClientMessage>> = {
   submit: { type: 'submit', prompt: 'hi' },
-  command: { type: 'command', name: 'help', args: 'x' },
+  command: { type: 'command', name: 'help', args: 'x', requestId: 'command-1' },
   abort: { type: 'abort' },
   'cancel-queue': { type: 'cancel-queue' },
   'get-messages': { type: 'get-messages' },
+  'get-history': { type: 'get-history', fromIndex: 40 },
+  'get-prompts': { type: 'get-prompts' },
   'get-context': { type: 'get-context' },
+  'get-commands': { type: 'get-commands' },
+  'get-status': { type: 'get-status' },
+  'list-models': { type: 'list-models', requestId: 'request-6' },
+  'get-agent-definitions': { type: 'get-agent-definitions', requestId: 'request-7' },
+  'list-sessions': { type: 'list-sessions', requestId: 'request-3' },
+  'new-session': { type: 'new-session', requestId: 'request-4' },
+  'switch-session': { type: 'switch-session', sessionId: 'session-2', requestId: 'request-5' },
+  'rename-session': {
+    type: 'rename-session',
+    sessionId: 'session-2',
+    name: 'Renamed',
+    requestId: 'request-6',
+  },
+  'delete-session': { type: 'delete-session', sessionId: 'session-2', requestId: 'request-7' },
   'get-usage-report': { type: 'get-usage-report' },
   'get-personal-usage-report': {
     type: 'get-personal-usage-report',
@@ -38,6 +55,16 @@ const CLIENT_SAMPLES: Readonly<Record<TClientMessage['type'], TClientMessage>> =
   'get-executing': { type: 'get-executing' },
   'get-pending': { type: 'get-pending' },
   'get-execution-workspace': { type: 'get-execution-workspace' },
+  'read-execution-detail': {
+    type: 'read-execution-detail',
+    requestId: 'detail-1',
+    entryId: 'main',
+    cursor: { offset: 20 },
+  },
+  'stop-waiting-loop': { type: 'stop-waiting-loop', requestId: 'loop-1' },
+  'project-status': { type: 'project-status', requestId: 'project-status-1' },
+  'project-diff': { type: 'project-diff', requestId: 'project-diff-1', path: 'a.txt' },
+  'project-memory': { type: 'project-memory', requestId: 'project-memory-1' },
   'get-background-tasks': {
     type: 'get-background-tasks',
     filter: { kind: 'agent', includeClosed: true },
@@ -58,6 +85,12 @@ const CLIENT_SAMPLES: Readonly<Record<TClientMessage['type'], TClientMessage>> =
   'ask-response': { type: 'ask-response', id: 'a1', response: { type: 'answer', values: ['y'] } },
   resume: { type: 'resume', lastSeq: 4 },
   ack: { type: 'ack', seq: 9 },
+  'get-settings': { type: 'get-settings', requestId: 'settings-1' },
+  'update-settings': {
+    type: 'update-settings',
+    requestId: 'settings-2',
+    patch: { field: 'outputStyle', styleId: 'concise' },
+  },
 };
 
 const SERVER_SAMPLES: Readonly<Record<TServerMessage['type'], TServerMessage>> = {
@@ -69,9 +102,93 @@ const SERVER_SAMPLES: Readonly<Record<TServerMessage['type'], TServerMessage>> =
   complete: { type: 'complete', result: {} as never },
   interrupted: { type: 'interrupted', result: {} as never },
   error: { type: 'error', message: 'm' },
-  command_result: { type: 'command_result', name: 'n', message: 'm', success: true },
-  messages: { type: 'messages', messages: [] },
+  command_result: {
+    type: 'command_result',
+    name: 'n',
+    message: 'm',
+    success: true,
+    requestId: 'command-1',
+  },
+  // #3288 §2: `display` is optional (an older host may not send it) and foreign-owned
+  // (`IHistoryDisplaySegment`, `agent-interface-session`) — checked shallowly here, same as
+  // `tool_start`'s `state`, per this file's own header.
+  messages: {
+    type: 'messages',
+    messages: [],
+    display: [
+      { type: 'text', role: 'user', content: 'hi' },
+      { type: 'tool', tool: { toolName: 'Bash', firstArg: 'ls', isRunning: false } as never },
+    ],
+  },
+  history: {
+    type: 'history',
+    startIndex: 3,
+    total: 4,
+    entries: [
+      {
+        id: 'e1',
+        timestamp: '2026-09-26T01:02:03.004Z',
+        category: 'event',
+        type: 'skill-activation',
+        data: { name: 'review' },
+      },
+    ],
+  },
   context: { type: 'context', state: {} as never },
+  history_changed: { type: 'history_changed' },
+  turn_source: { type: 'turn_source', source: 'peer' },
+  commands: { type: 'commands', commands: [], skills: [] },
+  session_status: { type: 'session_status', status: {} as never },
+  model_list: {
+    type: 'model_list',
+    requestId: 'request-6',
+    groups: [
+      { profileName: 'anthropic', providerLabel: 'Anthropic', models: [{ id: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6' }] },
+    ],
+    currentProfile: 'anthropic',
+    currentModel: 'claude-sonnet-4-6',
+  },
+  agent_definitions: {
+    type: 'agent_definitions',
+    requestId: 'request-7',
+    agents: [
+      { name: 'general-purpose', description: 'General-purpose task execution agent.', definedIn: 'Built-in' },
+      { name: 'Explore', description: 'Read-only codebase exploration agent.', definedIn: 'Built-in' },
+    ],
+    current: 'general-purpose',
+  },
+  sessions: { type: 'sessions', requestId: 'request-3', listing: {} as never },
+  sessions_error: {
+    type: 'sessions_error',
+    requestId: 'request-3',
+    code: 'list_failed',
+    message: 'unreadable store',
+  },
+  session_switched: { type: 'session_switched', event: { sessionId: 'session-2' } },
+  session_change_failed: {
+    type: 'session_change_failed',
+    code: 'prompt_pending',
+    message: 'Answer the pending prompt first.',
+    requestId: 'request-5',
+  },
+  session_renamed_in_list: {
+    type: 'session_renamed_in_list',
+    requestId: 'request-6',
+    sessionId: 'session-2',
+    name: 'Renamed',
+  },
+  session_rename_failed: {
+    type: 'session_rename_failed',
+    requestId: 'request-6',
+    message: 'No session session-2 in this workspace.',
+  },
+  session_deleted: { type: 'session_deleted', requestId: 'request-7', sessionId: 'session-2' },
+  session_delete_failed: {
+    type: 'session_delete_failed',
+    requestId: 'request-7',
+    code: 'live_elsewhere',
+    message: 'Another client is on this session.',
+  },
   usage_report: { type: 'usage_report', report: {} as never },
   personal_usage_report: {
     type: 'personal_usage_report',
@@ -98,8 +215,48 @@ const SERVER_SAMPLES: Readonly<Record<TServerMessage['type'], TServerMessage>> =
     message: 'not found',
   },
   executing: { type: 'executing', executing: false },
-  pending: { type: 'pending', pending: null },
+  pending: { type: 'pending', pending: null, pendingCount: 0 },
   execution_workspace_event: { type: 'execution_workspace_event', snapshot: {} as never },
+  execution_detail: {
+    type: 'execution_detail',
+    requestId: 'detail-1',
+    page: { entryId: 'main', records: [], nextCursor: { offset: 20 } },
+  },
+  execution_detail_error: {
+    type: 'execution_detail_error',
+    requestId: 'detail-1',
+    message: 'Unknown entry: main',
+  },
+  waiting_loop_stop: {
+    type: 'waiting_loop_stop',
+    requestId: 'loop-1',
+    outcome: { kind: 'stopped', loopId: 'loop-a', message: 'Stopped loop-a.' },
+  },
+  project_status: {
+    type: 'project_status',
+    requestId: 'project-status-1',
+    result: {
+      kind: 'status',
+      branch: 'main',
+      unborn: false,
+      files: [{ path: 'a.txt', status: 'Modified', added: 1, removed: 2 }],
+      truncated: false,
+    },
+  },
+  project_diff: {
+    type: 'project_diff',
+    requestId: 'project-diff-1',
+    result: {
+      kind: 'diff',
+      diffLines: [{ type: 'add', text: 'new line', lineNumber: 3 }],
+      truncated: false,
+    },
+  },
+  project_memory: {
+    type: 'project_memory',
+    requestId: 'project-memory-1',
+    result: { kind: 'memory', content: '# Memory', path: '.robota/memory/MEMORY.md', truncated: false },
+  },
   background_task_event: { type: 'background_task_event', event: {} as never },
   background_job_group_event: { type: 'background_job_group_event', event: {} as never },
   plan_event: { type: 'plan_event', event: {} as never },
@@ -122,8 +279,15 @@ const SERVER_SAMPLES: Readonly<Record<TServerMessage['type'], TServerMessage>> =
     taskId: 't',
     success: true,
   },
-  protocol_error: { type: 'protocol_error', message: 'm' },
+  protocol_error: { type: 'protocol_error', message: 'm', requestId: 'command-1' },
   resume_gap: { type: 'resume_gap' },
+  settings: { type: 'settings', requestId: 'settings-1', settings: {} as never },
+  settings_error: {
+    type: 'settings_error',
+    requestId: 'settings-1',
+    code: 'not_available',
+    message: 'Settings are not available on this host.',
+  },
 };
 
 const MALFORMED_CLIENT: ReadonlyArray<[string, unknown]> = [
@@ -170,6 +334,133 @@ const MALFORMED_CLIENT: ReadonlyArray<[string, unknown]> = [
   ['resume with a string lastSeq', { type: 'resume', lastSeq: '4' }],
   ['ack with NaN', { type: 'ack', seq: Number.NaN }],
   ['cancel-background-task with an empty taskId', { type: 'cancel-background-task', taskId: '' }],
+  ['list-sessions without requestId', { type: 'list-sessions' }],
+  ['list-models without requestId', { type: 'list-models' }],
+  ['list-models with an empty requestId', { type: 'list-models', requestId: '' }],
+  ['get-agent-definitions without requestId', { type: 'get-agent-definitions' }],
+  [
+    'get-agent-definitions with an empty requestId',
+    { type: 'get-agent-definitions', requestId: '' },
+  ],
+  ['get-history from a negative index', { type: 'get-history', fromIndex: -1 }],
+  ['get-history from a fractional index', { type: 'get-history', fromIndex: 1.5 }],
+  ['command with an empty requestId', { type: 'command', name: 'n', requestId: '' }],
+  ['switch-session with an empty sessionId', { type: 'switch-session', sessionId: '' }],
+  [
+    'switch-session with a numeric requestId',
+    { type: 'switch-session', sessionId: 's', requestId: 1 },
+  ],
+  ['new-session with an empty requestId', { type: 'new-session', requestId: '' }],
+  ['read-execution-detail without requestId', { type: 'read-execution-detail', entryId: 'main' }],
+  [
+    'read-execution-detail with an empty entryId',
+    { type: 'read-execution-detail', requestId: 'r', entryId: '' },
+  ],
+  [
+    'read-execution-detail with a negative offset',
+    { type: 'read-execution-detail', requestId: 'r', entryId: 'main', cursor: { offset: -1 } },
+  ],
+  [
+    'read-execution-detail with a string offset',
+    { type: 'read-execution-detail', requestId: 'r', entryId: 'main', cursor: { offset: '2' } },
+  ],
+  ['stop-waiting-loop without requestId', { type: 'stop-waiting-loop' }],
+  ['stop-waiting-loop with an empty requestId', { type: 'stop-waiting-loop', requestId: '' }],
+  ['get-settings without requestId', { type: 'get-settings' }],
+  ['get-settings with an empty requestId', { type: 'get-settings', requestId: '' }],
+  ['update-settings without a patch', { type: 'update-settings', requestId: 'r' }],
+  [
+    'update-settings with an unknown patch field',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'nope' } },
+  ],
+  [
+    'update-settings with a prototype-only patch field',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'toString' } },
+  ],
+  [
+    'update-settings language patch with a numeric language',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'language', language: 1 } },
+  ],
+  [
+    'update-settings outputStyle patch missing styleId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'outputStyle' } },
+  ],
+  [
+    'update-settings preset patch with an empty presetId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'preset', presetId: '' } },
+  ],
+  [
+    'update-settings permissionMode patch missing mode',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'permissionMode' } },
+  ],
+  [
+    'update-settings sandbox patch with a string enabled',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'sandbox', enabled: 'true' } },
+  ],
+  [
+    'update-settings removePermissionRule patch with an unknown kind',
+    {
+      type: 'update-settings',
+      requestId: 'r',
+      patch: { field: 'removePermissionRule', scope: 'user', kind: 'nope', pattern: 'Bash(*)' },
+    },
+  ],
+  [
+    'update-settings removePermissionRule patch missing pattern',
+    {
+      type: 'update-settings',
+      requestId: 'r',
+      patch: { field: 'removePermissionRule', scope: 'user', kind: 'allow' },
+    },
+  ],
+  [
+    'update-settings mcpServerEnabled patch missing serverId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'mcpServerEnabled', enabled: true } },
+  ],
+  [
+    'update-settings mcpServerEnabled patch with a string enabled',
+    {
+      type: 'update-settings',
+      requestId: 'r',
+      patch: { field: 'mcpServerEnabled', serverId: 'docs', enabled: 'true' },
+    },
+  ],
+  [
+    'update-settings pluginEnabled patch with an empty pluginId',
+    {
+      type: 'update-settings',
+      requestId: 'r',
+      patch: { field: 'pluginEnabled', pluginId: '', enabled: true },
+    },
+  ],
+  [
+    'update-settings installPlugin patch missing pluginId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'installPlugin' } },
+  ],
+  [
+    'update-settings uninstallPlugin patch with a numeric pluginId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'uninstallPlugin', pluginId: 1 } },
+  ],
+  [
+    'update-settings providerProfile patch missing profileName',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'providerProfile' } },
+  ],
+  [
+    'update-settings providerProfile patch with an empty profileName',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'providerProfile', profileName: '' } },
+  ],
+  [
+    'update-settings providerModel patch missing modelId',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'providerModel', profileName: 'anthropic' } },
+  ],
+  [
+    'update-settings providerModel patch missing profileName',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'providerModel', modelId: 'claude-haiku-4-5' } },
+  ],
+  [
+    'update-settings deleteProviderProfile patch missing profileName',
+    { type: 'update-settings', requestId: 'r', patch: { field: 'deleteProviderProfile' } },
+  ],
 ];
 
 const MALFORMED_SERVER: ReadonlyArray<[string, unknown]> = [
@@ -182,13 +473,120 @@ const MALFORMED_SERVER: ReadonlyArray<[string, unknown]> = [
   ['thinking with a string flag', { type: 'thinking', isThinking: 'yes' }],
   ['messages with a non-array', { type: 'messages', messages: {} }],
   ['messages with a primitive entry', { type: 'messages', messages: ['x'] }],
-  ['pending with a number', { type: 'pending', pending: 1 }],
+  ['messages with a numeric driverId', { type: 'messages', messages: [], driverId: 12345 }],
+  ['messages with a non-array display', { type: 'messages', messages: [], display: {} }],
+  ['messages with a display holding a primitive entry', { type: 'messages', messages: [], display: ['x'] }],
+  ['pending with a number', { type: 'pending', pending: 1, pendingCount: 1 }],
+  ['pending with a negative count', { type: 'pending', pending: null, pendingCount: -1 }],
+  ['pending with a fractional count', { type: 'pending', pending: 'p', pendingCount: 1.5 }],
   ['background_task with an array task', { type: 'background_task', taskId: 't', task: [] }],
   [
     'control result with an unknown action',
     { type: 'background_task_control_result', action: 'nuke', taskId: 't', success: true },
   ],
   ['command_result without success', { type: 'command_result', name: 'n', message: 'm' }],
+  [
+    'sessions_error with an unknown code',
+    { type: 'sessions_error', requestId: 'r', code: 'nope', message: 'm' },
+  ],
+  ['session_switched without event', { type: 'session_switched' }],
+  ['model_list without requestId', { type: 'model_list', groups: [], currentModel: 'm' }],
+  [
+    'model_list with a non-array groups',
+    { type: 'model_list', requestId: 'r', groups: {}, currentModel: 'm' },
+  ],
+  ['model_list without currentModel', { type: 'model_list', requestId: 'r', groups: [] }],
+  [
+    'agent_definitions without requestId',
+    { type: 'agent_definitions', agents: [], current: 'general-purpose' },
+  ],
+  [
+    'agent_definitions with a non-array agents',
+    { type: 'agent_definitions', requestId: 'r', agents: {}, current: 'general-purpose' },
+  ],
+  [
+    'agent_definitions with an agent missing definedIn',
+    {
+      type: 'agent_definitions',
+      requestId: 'r',
+      agents: [{ name: 'a', description: 'd' }],
+      current: 'a',
+    },
+  ],
+  ['agent_definitions without current', { type: 'agent_definitions', requestId: 'r', agents: [] }],
+  [
+    'session_change_failed with an unknown code',
+    { type: 'session_change_failed', code: 'nope', message: 'm' },
+  ],
+  ['session_change_failed without message', { type: 'session_change_failed', code: 'limit' }],
+  [
+    'session_change_failed with a numeric requestId',
+    { type: 'session_change_failed', code: 'limit', message: 'm', requestId: 1 },
+  ],
+  ['history without entries', { type: 'history', startIndex: 0, total: 0 }],
+  ['history without its place', { type: 'history', entries: [] }],
+  ['history with a negative total', { type: 'history', startIndex: 0, total: -1, entries: [] }],
+  ['history with a primitive entry', { type: 'history', startIndex: 0, total: 1, entries: ['x'] }],
+  [
+    'history with a numeric timestamp',
+    {
+      type: 'history',
+      startIndex: 0,
+      total: 1,
+      entries: [{ id: 'e', timestamp: 1, category: 'chat', type: 'user' }],
+    },
+  ],
+  [
+    'history with an entry missing its category',
+    {
+      type: 'history',
+      startIndex: 0,
+      total: 1,
+      entries: [{ id: 'e', timestamp: 't', type: 'user' }],
+    },
+  ],
+  [
+    'protocol_error with a numeric requestId',
+    { type: 'protocol_error', message: 'm', requestId: 1 },
+  ],
+  ['turn_source with an unknown source', { type: 'turn_source', source: 'robot' }],
+  ['turn_source without source', { type: 'turn_source' }],
+  ['execution_detail without page', { type: 'execution_detail', requestId: 'r' }],
+  ['execution_detail with an array page', { type: 'execution_detail', requestId: 'r', page: [] }],
+  ['execution_detail without requestId', { type: 'execution_detail', page: {} }],
+  ['execution_detail_error without message', { type: 'execution_detail_error', requestId: 'r' }],
+  ['waiting_loop_stop without outcome', { type: 'waiting_loop_stop', requestId: 'r' }],
+  [
+    'waiting_loop_stop with an unknown kind',
+    { type: 'waiting_loop_stop', requestId: 'r', outcome: { kind: 'paused' } },
+  ],
+  [
+    'waiting_loop_stop stopped without loopId',
+    { type: 'waiting_loop_stop', requestId: 'r', outcome: { kind: 'stopped' } },
+  ],
+  [
+    'waiting_loop_stop several without message',
+    { type: 'waiting_loop_stop', requestId: 'r', outcome: { kind: 'several' } },
+  ],
+  [
+    'waiting_loop_stop failed with a numeric loopId',
+    {
+      type: 'waiting_loop_stop',
+      requestId: 'r',
+      outcome: { kind: 'failed', loopId: 1, message: 'm' },
+    },
+  ],
+  [
+    'waiting_loop_stop with a prototype-only kind',
+    { type: 'waiting_loop_stop', requestId: 'r', outcome: { kind: 'toString' } },
+  ],
+  ['settings without requestId', { type: 'settings', settings: {} }],
+  ['settings with an array settings', { type: 'settings', requestId: 'r', settings: [] }],
+  [
+    'settings_error with an unknown code',
+    { type: 'settings_error', requestId: 'r', code: 'nope', message: 'm' },
+  ],
+  ['settings_error without message', { type: 'settings_error', requestId: 'r', code: 'invalid' }],
 ];
 
 describe('decodeClientMessage (issue #2045)', () => {
@@ -206,12 +604,42 @@ describe('decodeClientMessage (issue #2045)', () => {
     expect(decodeClientMessage(value).ok).toBe(false);
   });
 
+  // #3282 §4b: "Providers & Models" — Use, Model and Delete each add one `update-settings` patch
+  // field; `CLIENT_SAMPLES` above only round-trips one field (`outputStyle`) per variant, so these
+  // three get their own explicit round trip.
+  it.each([
+    { field: 'providerProfile', profileName: 'backup' },
+    { field: 'providerModel', profileName: 'backup', modelId: 'claude-haiku-4-5' },
+    { field: 'deleteProviderProfile', profileName: 'backup' },
+  ])('decodes an update-settings patch with field %j', (patch) => {
+    const message = { type: 'update-settings', requestId: 'r', patch };
+    expect(decodeClientMessage(JSON.parse(JSON.stringify(message)))).toEqual({
+      ok: true,
+      message,
+    });
+  });
+
   it('keeps the protocol wording for a bad submit prompt', () => {
     expect(decodeClientMessage({ type: 'submit', prompt: 1 })).toEqual({
       ok: false,
       reason: 'prompt must be a non-empty string',
     });
   });
+
+  it.each([
+    { field: 'mcpServerEnabled', serverId: 'docs', enabled: true },
+    { field: 'reloadMcpServers' },
+    { field: 'pluginEnabled', pluginId: 'formatter@robota', enabled: false },
+    { field: 'reloadPlugins' },
+    { field: 'installPlugin', pluginId: 'linter@robota' },
+    { field: 'uninstallPlugin', pluginId: 'formatter@robota' },
+  ] as const)('accepts the $field settings patch (#3282 §4 part b-2)', (patch) => {
+    const message = { type: 'update-settings' as const, requestId: 'r', patch };
+    expect(decodeClientMessage(JSON.parse(JSON.stringify(message)))).toEqual({
+      ok: true,
+      message,
+    });
+  });
 });
 
 describe('decodeServerMessage (issue #2045)', () => {
@@ -228,6 +656,68 @@ describe('decodeServerMessage (issue #2045)', () => {
   it.each(MALFORMED_SERVER)('refuses %s', (_label, value) => {
     expect(decodeServerMessage(value).ok).toBe(false);
   });
+
+  it('accepts every refusal code the session contracts declare, and a refusal without requestId', () => {
+    for (const code of SESSION_CHANGE_REFUSAL_CODES) {
+      expect(decodeServerMessage({ type: 'session_change_failed', code, message: 'm' }).ok).toBe(
+        true,
+      );
+    }
+  });
+
+  it('accepts every waiting-loop stop outcome', () => {
+    for (const outcome of [
+      { kind: 'none' },
+      { kind: 'several', message: 'Use /loop stop <id>.' },
+      { kind: 'stopped', loopId: 'loop-a' },
+      { kind: 'failed', message: 'store unavailable' },
+      { kind: 'failed', loopId: 'loop-a', message: 'store unavailable' },
+    ]) {
+      expect(decodeServerMessage({ type: 'waiting_loop_stop', requestId: 'r', outcome }).ok).toBe(
+        true,
+      );
+    }
+  });
+
+  it('accepts a pending frame without its count, as a host from before the count sends it', () => {
+    // Refusing it would cut a newer client off from an older daemon on every prompt it queues.
+    expect(decodeFrame('{"type":"pending","pending":null}', decodeServerMessage)).toEqual({
+      ok: true,
+      message: { type: 'pending', pending: null },
+    });
+  });
+
+  it('accepts an error frame carrying its classification (#3289 §3), and one without it', () => {
+    const classified = {
+      type: 'error',
+      message: 'Authentication Error: invalid x-api-key',
+      code: 'rate_limit',
+      provider: 'anthropic',
+      retryAfterSeconds: 30,
+    };
+    expect(decodeServerMessage(classified)).toEqual({ ok: true, message: classified });
+    expect(decodeServerMessage({ type: 'error', message: 'boom' })).toEqual({
+      ok: true,
+      message: { type: 'error', message: 'boom' },
+    });
+  });
+
+  it('accepts an error frame naming the model a model_unavailable failure tried', () => {
+    const classified = {
+      type: 'error',
+      message: 'No model available for provider "anthropic"',
+      code: 'model_unavailable',
+      provider: 'anthropic',
+      model: 'claude-x',
+    };
+    expect(decodeServerMessage(classified)).toEqual({ ok: true, message: classified });
+  });
+
+  it('refuses an error frame with an unrecognized code', () => {
+    expect(
+      decodeServerMessage({ type: 'error', message: 'm', code: 'not-a-real-code' }).ok,
+    ).toBe(false);
+  });
 });
 
 describe('decodeFrame — the one carrier path', () => {