mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
RpcDispatcher now requires its method list, so these suites can no longer consume the default manifest. Suites that still reach the registry through the RPC server keep the guard. Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
271 lines
9.9 KiB
TypeScript
271 lines
9.9 KiB
TypeScript
import { execFileSync } from 'node:child_process'
|
|
import { stripTypeScriptTypes } from 'node:module'
|
|
import { beforeAll, expect, it, vi } from 'vitest'
|
|
import {
|
|
call,
|
|
hostStub
|
|
} from '../../../src/main/runtime/rpc/methods/structured-sessions/protocol/structured-agent-session-rpc.test-fixture'
|
|
|
|
import { STRUCTURED_CLIENT } from '../../../src/main/runtime/rpc/methods/structured-sessions/protocol/structured-agent-session-rpc-client.test-fixture'
|
|
import { setStructuredAgentSessionHost } from '../../../src/main/native-chat/agent-session-wire/host/structured-agent-session-registry'
|
|
import { createAgentModelCatalogService } from '../../../src/main/native-chat/agent-model-catalog/agent-model-catalog-service'
|
|
import { AgentModelCatalogStore } from '../../../src/main/native-chat/agent-model-catalog/agent-model-catalog-store'
|
|
import {
|
|
runAgentModelCatalogSession,
|
|
AgentModelCatalogProbeError
|
|
} from '../../../src/main/native-chat/agent-model-catalog/agent-model-catalog-probe-runner'
|
|
import { createClaudeModelCatalogProbe } from '../../../src/main/claude/claude-model-catalog-probe'
|
|
|
|
import { prepareReleaseCheckoutSnapshot, REPO_ROOT } from './release-checkout'
|
|
import { LOCAL_RELEASE_GIT_ENV } from './release-checkout-process'
|
|
|
|
beforeAll(async () => {
|
|
await prepareReleaseCheckoutSnapshot('v1.4.229')
|
|
}, 180_000)
|
|
|
|
// Local acceptance rig: execute the pinned source, with only React's effect scheduler and transport replaced.
|
|
function released(path: string, names: string[], dependencies: Record<string, unknown> = {}) {
|
|
const source = execFileSync('git', ['show', `v1.4.229:${path}`], {
|
|
cwd: REPO_ROOT,
|
|
env: { ...process.env, ...LOCAL_RELEASE_GIT_ENV },
|
|
encoding: 'utf8'
|
|
})
|
|
.replace(
|
|
'constructor(private readonly options: RequestTrackerOptions) {}',
|
|
'constructor(options: RequestTrackerOptions) { this.options = options; }'
|
|
)
|
|
.replace(
|
|
/constructor\(\s*readonly code: string,[\s\S]*?super\(message\)\s*\}/,
|
|
'constructor(code: string, message: string, data?: unknown) { super(message); this.code = code; this.data = data; }'
|
|
)
|
|
const javascript = stripTypeScriptTypes(source)
|
|
.replace(/import[\s\S]*?from\s*['"][^'"]+['"];?/g, '')
|
|
.replace(/export /g, '')
|
|
return new Function(
|
|
...Object.keys(dependencies),
|
|
`${javascript}; return { ${names.join(', ')} };`
|
|
)(...Object.values(dependencies))
|
|
}
|
|
|
|
it.each(['success', 'budget'] as const)(
|
|
'released one-follow tracker accepts direct legacy %s with enterprise retry and cleanup under modern saturation',
|
|
async (mode) => {
|
|
vi.useFakeTimers()
|
|
const start = Date.now()
|
|
const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
|
|
const attempts: boolean[] = []
|
|
let closes = 0
|
|
let output = [
|
|
{
|
|
response: {
|
|
subtype: 'success',
|
|
request_id: 'orca-model-discovery',
|
|
response: { models: [{ value: 'opus', supportsFastMode: true }] }
|
|
}
|
|
},
|
|
{
|
|
response: {
|
|
subtype: 'success',
|
|
request_id: 'orca-model-settings',
|
|
response: { applied: {} }
|
|
}
|
|
}
|
|
]
|
|
.map((row) => JSON.stringify(row))
|
|
.join('\n')
|
|
const probe = createClaudeModelCatalogProbe({
|
|
resolveCommand: () => ({ command: process.execPath, prefixArgs: [] }),
|
|
resolveEnv: () => ({}),
|
|
resolveInheritedEnv: async () => ({}),
|
|
resolveAuthPolicy: () => ({ account: 'system' }),
|
|
runListing: (launch, options) => {
|
|
const strict = launch.args.includes('--strict-mcp-config')
|
|
attempts.push(strict)
|
|
return runAgentModelCatalogSession(
|
|
() => ({
|
|
close: async () => {
|
|
if (!strict) {
|
|
await wait(6_000)
|
|
}
|
|
closes++
|
|
}
|
|
}),
|
|
async () => {
|
|
await wait(strict ? 14_000 : mode === 'success' ? 8_000 : 60_000)
|
|
if (strict) {
|
|
throw new AgentModelCatalogProbeError('enterprise policy', 'exit', false, {
|
|
exitCode: 1,
|
|
stdout: '',
|
|
stderr:
|
|
'You cannot use --strict-mcp-config when an enterprise MCP config is present'
|
|
})
|
|
}
|
|
return output
|
|
},
|
|
{ label: 'released-acceptance', signal: options.signal }
|
|
)
|
|
}
|
|
})
|
|
const modern = vi.fn(
|
|
(signal?: AbortSignal) =>
|
|
new Promise<never>((_resolve, reject) => {
|
|
signal?.addEventListener('abort', () => reject(new Error('stopped')), { once: true })
|
|
})
|
|
)
|
|
const home = { variable: 'CLAUDE_CONFIG_DIR', path: '/qa-account' }
|
|
// A command line relative to each folder lists per folder, so five folders saturate admission.
|
|
const scoped = Object.assign(probe, {
|
|
resolve: async (
|
|
_home: unknown,
|
|
_cwd: string,
|
|
_lookup: unknown,
|
|
_operation: unknown,
|
|
launchDirectory?: string
|
|
) => ({
|
|
identity: { command: 'qa-modern', cwd: launchDirectory },
|
|
run: modern
|
|
})
|
|
})
|
|
const service = createAgentModelCatalogService({
|
|
store: new AgentModelCatalogStore(),
|
|
getRecord: () => undefined,
|
|
getConversation: () => undefined,
|
|
drivesRecord: () => true,
|
|
resolveAccountHome: async () => home,
|
|
probes: { claude: scoped }
|
|
})
|
|
setStructuredAgentSessionHost(
|
|
Object.assign(hostStub(), {
|
|
readModelCatalog: async (params: Parameters<typeof service.read>[0]) => {
|
|
if (!params.savedOnly) {
|
|
void service.demand(params)
|
|
}
|
|
return service.read(params)
|
|
},
|
|
deps: {
|
|
modelCatalog: service,
|
|
store: { getRecord: () => undefined, getConversation: () => undefined },
|
|
adapter: {}
|
|
}
|
|
})
|
|
)
|
|
const budget = released('mobile/src/transport/rpc-request-budget.ts', [
|
|
'openRpcRequestBudget',
|
|
'resolvePostConnectRequestTimeout'
|
|
])
|
|
const ambiguity = released('mobile/src/transport/rpc-delivery-ambiguity.ts', [
|
|
'markRpcDeliveryUnknown'
|
|
])
|
|
const { RpcClientRequestTracker } = released(
|
|
'mobile/src/transport/rpc-client-request-tracker.ts',
|
|
['RpcClientRequestTracker'],
|
|
{ ...budget, ...ambiguity }
|
|
)
|
|
let sequence = 0
|
|
const frames: { params?: unknown }[] = []
|
|
const receipts: boolean[] = []
|
|
const tracker = new RpcClientRequestTracker({
|
|
nextId: () => String(++sequence),
|
|
getState: () => 'connected',
|
|
waitForConnected: async () => {},
|
|
sendFrame: (frame: { id: string; method: string; params?: unknown }) => {
|
|
frames.push(frame)
|
|
void call(frame.method, frame.params, STRUCTURED_CLIENT).then((response) => {
|
|
receipts.push(tracker.resolve({ ...response, id: frame.id }))
|
|
})
|
|
return true
|
|
}
|
|
})
|
|
const { callAgentSession } = released(
|
|
'mobile/src/session/mobile-structured-agent-session-rpc.ts',
|
|
['callAgentSession']
|
|
)
|
|
let cleanup: (() => void) | undefined
|
|
const applied: unknown[] = []
|
|
let landed = 0
|
|
const record = {}
|
|
const { useMobileHostModelCatalogUpgrade } = released(
|
|
'mobile/src/session/use-mobile-host-model-catalog-upgrade.ts',
|
|
['useMobileHostModelCatalogUpgrade'],
|
|
{
|
|
callAgentSession,
|
|
useEffect: (effect: () => () => void) => {
|
|
cleanup = effect()
|
|
},
|
|
applyStructuredAgentSessionModelCatalog: (
|
|
_state: unknown,
|
|
_seed: unknown,
|
|
catalog: unknown
|
|
) => {
|
|
applied.push(catalog)
|
|
return { record }
|
|
},
|
|
settleStructuredAgentSessionBuiltinCatalog: () => {
|
|
throw new Error('released caller timed out')
|
|
}
|
|
}
|
|
)
|
|
try {
|
|
await Promise.all(
|
|
['/1', '/2', '/3', '/4', '/5'].map((workspacePath) => {
|
|
void service.demand({ agent: 'claude', workspacePath })
|
|
return service.read({ agent: 'claude', workspacePath })
|
|
})
|
|
)
|
|
await vi.advanceTimersByTimeAsync(0)
|
|
expect(modern).toHaveBeenCalledTimes(2)
|
|
useMobileHostModelCatalogUpgrade({
|
|
agent: 'claude',
|
|
client: tracker,
|
|
sessionId: 'released',
|
|
enabled: true,
|
|
newLaunch: false,
|
|
fence: 1,
|
|
optionCatalog: {},
|
|
activeOptionRecordRef: { current: record },
|
|
updateOptionState: (update: (state: { record: object }) => unknown) => update({ record }),
|
|
onListingLanded: () => landed++
|
|
})
|
|
await vi.advanceTimersByTimeAsync(0)
|
|
expect(frames).toHaveLength(2)
|
|
await vi.advanceTimersByTimeAsync(36_000)
|
|
expect(attempts).toEqual([true, false])
|
|
expect(closes).toBe(2)
|
|
expect(receipts).toEqual([true, true])
|
|
expect(tracker.size()).toBe(0)
|
|
expect(applied.at(-1)).not.toHaveProperty('listingInProgress')
|
|
expect(landed).toBe(mode === 'success' ? 1 : 0)
|
|
expect(Date.now() - start).toBeLessThan(45_000)
|
|
if (mode === 'success') {
|
|
cleanup?.()
|
|
await vi.advanceTimersByTimeAsync(120_001)
|
|
output = output.replace('opus', 'sonnet')
|
|
useMobileHostModelCatalogUpgrade({
|
|
agent: 'claude',
|
|
client: tracker,
|
|
sessionId: 'released',
|
|
enabled: true,
|
|
newLaunch: false,
|
|
fence: 1,
|
|
optionCatalog: {},
|
|
activeOptionRecordRef: { current: record },
|
|
updateOptionState: (update: (state: { record: object }) => unknown) => update({ record })
|
|
})
|
|
await vi.advanceTimersByTimeAsync(0)
|
|
expect(frames).toHaveLength(3)
|
|
expect(applied.at(-1)).toMatchObject({ models: [{ id: 'opus' }] })
|
|
await vi.advanceTimersByTimeAsync(34_000)
|
|
expect(frames).toHaveLength(3)
|
|
expect(
|
|
await service.read({ agent: 'claude', legacy: true, savedOnly: true })
|
|
).toMatchObject({ models: [{ id: 'sonnet' }] })
|
|
}
|
|
} finally {
|
|
cleanup?.()
|
|
service.stop()
|
|
await vi.advanceTimersByTimeAsync(0)
|
|
vi.useRealTimers()
|
|
}
|
|
}
|
|
)
|