orca/src/renderer/src/lib/launch-structured-agent-session.test.ts

import { beforeEach, describe, expect, it, vi } from 'vitest'
import { structuredAgentSessionPayloadFingerprint } from '../../../shared/structured-agent-session-mutation'
import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
import {
  createStructuredAgentSessionLaunchIntent,
  launchStructuredAgentSession,
  StructuredAgentSessionCreateRefusalError
} from './launch-structured-agent-session'

vi.mock('@/runtime/structured-agent-session-client', () => ({
  callStructuredAgentSession: vi.fn()
}))

describe('structured agent session launch', () => {
  beforeEach(() => {
    vi.mocked(callStructuredAgentSession).mockReset()
  })

  it('creates a native session with a host-verifiable launch intent', async () => {
    vi.mocked(callStructuredAgentSession).mockImplementation(async (_target, _method, params) => ({
      ok: true,
      replayed: false,
      fence: 1,
      cursor: { epoch: 'epoch-1', sequence: 0 },
      value: {
        sessionId: (params as { envelope: { sessionId: string } }).envelope.sessionId,
        fence: 1,
        page: {
          sessionId: 'session-1',
          epoch: 'epoch-1',
          direction: 'tail',
          items: [],
          removedItemIds: [],
          submissions: [],
          window: {
            oldest: null,
            newest: null,
            nextCursor: { epoch: 'epoch-1', sequence: 0 }
          },
          liveCursor: { epoch: 'epoch-1', sequence: 0 },
          hasOlder: false,
          hasNewer: false
        },
        unconfirmedClientMessageIds: []
      }
    }))

    const intent = createStructuredAgentSessionLaunchIntent('workspace-1', 'codex')
    const receipt = await launchStructuredAgentSession(intent)
    const params = vi.mocked(callStructuredAgentSession).mock.calls[0]?.[2] as {
      envelope: { sessionId: string; payloadFingerprint: string }
      worktree: string
      agent: 'codex'
    }

    expect(receipt).toEqual({
      sessionId: expect.stringMatching(/^codex_[A-Za-z0-9_]{36}$/),
      fence: 1
    })
    expect(callStructuredAgentSession).toHaveBeenCalledWith(
      { kind: 'local' },
      'agentSession.create',
      expect.objectContaining({ worktree: 'id:workspace-1', agent: 'codex' })
    )
    expect(params.envelope.payloadFingerprint).toBe(
      structuredAgentSessionPayloadFingerprint({
        method: 'agentSession.create',
        sessionId: params.envelope.sessionId,
        fields: { worktree: 'id:workspace-1', agent: 'codex' }
      })
    )
    expect(params).toBe(intent.params)
  })

  it('names Claude as the create provider and in the session id', () => {
    const intent = createStructuredAgentSessionLaunchIntent('workspace-1', 'claude')
    expect(intent.sessionId).toMatch(/^claude_[A-Za-z0-9_]{36}$/)
    expect(intent.params.agent).toBe('claude')
    expect(intent.params.envelope.payloadFingerprint).toBe(
      structuredAgentSessionPayloadFingerprint({
        method: 'agentSession.create',
        sessionId: intent.sessionId,
        fields: { worktree: 'id:workspace-1', agent: 'claude' }
      })
    )
  })

  it('asks the executing host for create support before creating a Claude session', async () => {
    vi.mocked(callStructuredAgentSession).mockImplementation(async (_target, method) =>
      method === 'agentSession.createSupport'
        ? { supported: true }
        : { ok: true, replayed: false, value: { sessionId: 'claude_1', fence: 1 } }
    )

    const intent = createStructuredAgentSessionLaunchIntent('workspace-1', 'claude')
    await launchStructuredAgentSession(intent)

    expect(vi.mocked(callStructuredAgentSession).mock.calls.map(([, method]) => method)).toEqual([
      'agentSession.createSupport',
      'agentSession.create'
    ])
    expect(callStructuredAgentSession).toHaveBeenNthCalledWith(
      1,
      { kind: 'local' },
      'agentSession.createSupport',
      { worktree: 'id:workspace-1', agent: 'claude' }
    )
  })

  it('refuses a Claude launch the host says it cannot support, without creating', async () => {
    vi.mocked(callStructuredAgentSession).mockResolvedValue({ supported: false, reason: 'agent' })

    const intent = createStructuredAgentSessionLaunchIntent('workspace-1', 'claude')

    await expect(launchStructuredAgentSession(intent)).rejects.toBeInstanceOf(
      StructuredAgentSessionCreateRefusalError
    )
    expect(vi.mocked(callStructuredAgentSession).mock.calls.map(([, method]) => method)).toEqual([
      'agentSession.createSupport'
    ])
  })

  it('fails closed when the create support probe cannot be answered', async () => {
    vi.mocked(callStructuredAgentSession).mockRejectedValue(new Error('runtime unreachable'))

    const intent = createStructuredAgentSessionLaunchIntent('workspace-1', 'claude')

    await expect(launchStructuredAgentSession(intent)).rejects.toBeInstanceOf(
      StructuredAgentSessionCreateRefusalError
    )
    expect(callStructuredAgentSession).toHaveBeenCalledOnce()
  })

  /** Codex's support answer is settled by the launch route and owned elsewhere; this pins that the
   *  Claude probe did not change Codex's wire traffic. */
  it('does not probe create support for Codex', async () => {
    vi.mocked(callStructuredAgentSession).mockResolvedValue({
      ok: true,
      replayed: false,
      value: { sessionId: 'codex_1', fence: 1 }
    })

    await launchStructuredAgentSession(
      createStructuredAgentSessionLaunchIntent('workspace-1', 'codex')
    )

    expect(vi.mocked(callStructuredAgentSession).mock.calls.map(([, method]) => method)).toEqual([
      'agentSession.create'
    ])
  })

  it('replays the exact create envelope when an unknown outcome is retried', async () => {
    const intent = createStructuredAgentSessionLaunchIntent('workspace-retry', 'codex')
    vi.mocked(callStructuredAgentSession).mockRejectedValue(new Error('response lost'))

    await expect(launchStructuredAgentSession(intent)).rejects.toThrow('response lost')
    await expect(launchStructuredAgentSession(intent)).rejects.toThrow('response lost')

    const first = vi.mocked(callStructuredAgentSession).mock.calls[0]?.[2]
    const second = vi.mocked(callStructuredAgentSession).mock.calls[1]?.[2]
    expect(first).toBe(intent.params)
    expect(second).toBe(first)
    expect(intent.params.envelope.clientOperationId).toMatch(/^\d{13}-[0-9a-f]{32}$/)
  })
})