Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
fix(runtime): discover native model catalogs when opening the picker (#973)
Gustavo Yecde36a00a71d
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 34f5ad5b8..66541c99c 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -267,7 +267,7 @@ jobs:needs: scopeif: needs.scope.outputs.run_linux == 'true'runs-on: ubuntu-latest- timeout-minutes: 25+ timeout-minutes: 45env:RUN_COVERAGE: ${{ github.event_name != 'push' || startsWith(github.event.head_commit.message, 'release:') }}steps:diff --git a/scripts/ci/workflow-contract.test.ts b/scripts/ci/workflow-contract.test.tsindex dedf352ab..e38951f05 100644--- a/scripts/ci/workflow-contract.test.ts+++ b/scripts/ci/workflow-contract.test.ts@@ -1025,7 +1025,7 @@ describe("Turbo CI execution", () => {it("keeps package builds away from dist consumers and uploads one merged Istanbul report", () => {const linux = ciJob("test-linux")- expect(linux).toContain("timeout-minutes: 25")+ expect(linux).toContain("timeout-minutes: 45")expect(linux).toContain("RUN_COVERAGE: ${{ github.event_name != 'push' || startsWith(github.event.head_commit.message, 'release:') }}",)diff --git a/src/daemon/agent-driver/README.md b/src/daemon/agent-driver/README.mdindex b70b64f16..f407b7fa9 100644--- a/src/daemon/agent-driver/README.md+++ b/src/daemon/agent-driver/README.md@@ -228,6 +228,8 @@ Discovery and launch share the same executable lookup: an explicit `command`,is used only when `LOCALAPPDATA` is absent). Run the selected CLI executable in a terminal and finishGoogle sign-in before starting a bot; ACP authentication is separate.+Opening the model list runs the native `agy models` command and preserves its returned slugs and labels. Installation checks and Bot launch do not run that command. The model list does not establish an authenticated model request or infer per-model effort support.+The CLI must advertise native `--input-format stream-json`,`--output-format stream-json` and `--conversation` support. Alook keeps oneprocess across turns and queues busy input until the current result completes.@@ -278,19 +280,9 @@ Authentication is local to Google's ACP server. Complete Google sign-in using anACP client's `authenticate` request with `methodId: "oauth-personal"` beforelaunching an agent. The provider's settings live under`~/.gemini/antigravity-acp/`; leave credentials there and never put them in agent-instructions. Runtime detection initializes the protocol and requests a session catalog without-authenticating or sending a prompt. Healthy means the native binary is compatible,-not that an account is signed in; unauthenticated discovery has no model catalog.-The catalog probe can create an empty provider session. The adapter does not-send an `authenticate` request during discovery or launch. It reports explicit-provider authentication errors when returned. In native 1.3.0 testing, unreadable-Keychain credentials with no valid file fallback left `session/load` waiting for-login and discovery ended with `antigravity_acp_timeout` at the existing 10-second-deadline. A separate 30-second diagnostic on the same credential condition was-correlated with an opened Google sign-in page by its OAuth callback port. The-native server can therefore start its own browser login flow during discovery,-even though the adapter does not send `authenticate`. Complete native sign-in-before running the daemon; a timeout does not establish that credentials are valid.+instructions. Runtime detection initializes the protocol and exits; it does not authenticate or create/load a session. Healthy means the native binary is compatible, not that an account is signed in.++Opening the model list requests a session catalog, reusing the discovery session when available. This can create an empty provider session. The adapter does not send `authenticate` during discovery or launch, but native 1.3.0 can start its own browser login when a session request needs credentials. Complete native sign-in before discovering its models or running a Bot. A catalog timeout does not establish that credentials are valid; it leaves the installed runtime health unchanged.Standing instructions accompany the first prompt of every physical session,including resumed sessions. Later prompts reuse its context. Tools use ACP@@ -329,3 +321,9 @@ Keychain store remained unreadable on the tested machine and had no file fallbacthat condition reports retryable unavailable before HTTP, not an authenticationrefusal. These results supersede the earlier Google location-eligibility blockand do not establish default Keychain access or acceptance on other platforms.++### Model discovery++`probe({ backend, includeModels: false })` checks installation and native protocol compatibility without discovering model catalogs. The daemon uses this mode at machine startup. Antigravity ACP initializes and exits without authenticating or creating/loading a catalog session; Grok also stops after its compatibility handshake.++Opening a model list requests the selected machine and backend through the owner-scoped API and machine control WebSocket. The default SDK probe retains each backend's native catalog discovery. The result is correlated by request ID and saved in the existing machine runtime report. Backends without a native catalog return no catalog; their custom model entry remains available. Discovery does not wake or reset a Bot, and catalog errors do not change installed runtime health. Native catalog discovery may require the user's existing vendor login.diff --git a/src/daemon/agent-driver/src/adapters/agy/index.ts b/src/daemon/agent-driver/src/adapters/agy/index.tsindex b0b9460ca..82029ad37 100644--- a/src/daemon/agent-driver/src/adapters/agy/index.ts+++ b/src/daemon/agent-driver/src/adapters/agy/index.ts@@ -38,7 +38,7 @@ export class AgyDriver implements BackendAdapter<"agy"> {constructor(private readonly launchSpec?: ReturnType<typeof agySpawnSpec>) {}- probe(command?: string) { return probeAgy(command); }+ probe(command?: string, includeModels = true) { return probeAgy(command, includeModels); }async openLane(ctx: AdapterLaunchContext<"agy">, options?: { onRawStdoutLine?: (line: string) => void }) {const spec = agySpawnSpec(resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command);diff --git a/src/daemon/agent-driver/src/adapters/agy/native.windows.test.ts b/src/daemon/agent-driver/src/adapters/agy/native.windows.test.tsindex 47c3f3a64..7505d3068 100644--- a/src/daemon/agent-driver/src/adapters/agy/native.windows.test.ts+++ b/src/daemon/agent-driver/src/adapters/agy/native.windows.test.ts@@ -39,8 +39,10 @@ describe.skipIf(process.platform !== "win32" || !native)("official Windows agy 1const command = mode === "explicit" ? entry : undefined;expect(statSync(agySpawnSpec(command).command)).toMatchObject({ dev, ino });const sdk = createAgentDriverSdk();- expect(await sdk.probe({ backend: "agy", ...(command ? { command } : {}) })).toMatchObject({ status: "healthy", version: "1.3.4" });+ const result = await sdk.probe({ backend: "agy", includeModels: false, ...(command ? { command } : {}) });+ console.log(JSON.stringify({ mode, status: result.status, version: result.status === "healthy" ? result.version : undefined, errorCode: result.status === "unhealthy" ? result.error.code : undefined }));+ expect(result).toMatchObject({ status: "healthy", version: "1.3.4" });console.log(JSON.stringify({ backend: "agy", mode, os: release(), node: process.version,- sha512: createHash("sha512").update(readFileSync(entry)).digest("hex"), version: "1.3.4", probe: "healthy" }));+ sha512: createHash("sha512").update(readFileSync(entry)).digest("hex"), version: "1.3.4", probe: "healthy", includeModels: false }));}, 60_000);});diff --git a/src/daemon/agent-driver/src/adapters/agy/probe.test.ts b/src/daemon/agent-driver/src/adapters/agy/probe.test.tsindex ca85fbb7e..6f30be904 100644--- a/src/daemon/agent-driver/src/adapters/agy/probe.test.ts+++ b/src/daemon/agent-driver/src/adapters/agy/probe.test.ts@@ -1,8 +1,9 @@-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";import { afterEach, describe, expect, it, vi } from "vitest";-import { agySpawnSpec, probeAgy } from "./probe.js";+import { agySpawnSpec, probeAgy, parseAgyModelCatalog } from "./probe.js";+import { createAgentDriverSdk } from "../../index.js";const directories: string[] = [];afterEach(() => { vi.unstubAllEnvs(); for (const directory of directories.splice(0)) rmSync(directory, { recursive: true, force: true }); });@@ -49,3 +50,42 @@ describe("official agy entry", () => {expect(await probeAgy(join(directory(), "missing"))).toMatchObject({ status: "unhealthy" });});});+++describe("AGY on-demand native catalog", () => {+ it.skipIf(process.platform === "win32")("rejects a successful native command with no usable model rows", async () => {+ const command = join(directory(), "agy");+ writeFileSync(command, `#!${process.execPath}\nif(process.argv.includes('--version'))console.log('1.3.5');else if(process.argv.includes('--help'))console.error('--input-format --output-format stream-json --conversation models');else console.log('No available models');\n`, { mode: 0o755 });+ expect(await createAgentDriverSdk().probe({ backend: "agy", command })).toMatchObject({ status: "unhealthy", error: { code: "agy_model_catalog_invalid" } });+ });+ it.skipIf(process.platform === "win32")("keeps installation healthy when the native catalog requires authentication", async () => {+ const root = directory();+ const command = join(root, "agy");+ const calls = join(root, "calls");+ writeFileSync(command, `#!${process.execPath}\nconst fs=require('node:fs');fs.appendFileSync(${JSON.stringify(calls)},process.argv[2]+String.fromCharCode(10));if(process.argv.includes('--version'))console.log('1.3.4');else if(process.argv.includes('--help'))console.error('--input-format --output-format stream-json --conversation models');else{console.error('Please sign in to view available models');process.exit(1);}\n`, { mode: 0o755 });+ const sdk = createAgentDriverSdk();+ expect(await sdk.probe({ backend: "agy", command, includeModels: false })).toMatchObject({ status: "healthy", version: "1.3.4" });+ expect(readFileSync(calls, "utf8")).toBe("--version\n--help\n");+ expect(await sdk.probe({ backend: "agy", command })).toMatchObject({ status: "unhealthy", error: { code: "agy_model_probe_failed" } });+ expect(readFileSync(calls, "utf8")).toBe("--version\n--help\n--version\n--help\nmodels\n");+ expect(await sdk.probe({ backend: "agy", command, includeModels: false })).toMatchObject({ status: "healthy", version: "1.3.4" });+ });+ it("reads TSV output, rejects diagnostics, deduplicates and bounds models", () => {+ expect(parseAgyModelCatalog("Fetching models...\nmodel-high\tNative high\nmodel-high\tDuplicate\nmodel-low\tNative low\n")).toEqual({ updateMode: "unsupported", models: [+ { id: "model-high", displayName: "Native high", supportedReasoningEfforts: [] },+ { id: "model-low", displayName: "Native low", supportedReasoningEfforts: [] },+ ] });+ expect(parseAgyModelCatalog(Array.from({ length: 1025 }, (_, index) => `model-${index}\tNative ${index}`).join("\n"))?.models).toHaveLength(1024);+ expect(parseAgyModelCatalog("Sign in first")).toBeUndefined();+ });+ it.skipIf(process.platform === "win32")("runs models only for an explicit catalog probe", async () => {+ const root = directory();+ const file = join(root, "agy");+ const calls = join(root, "calls");+ writeFileSync(file, `#!${process.execPath}\nconst fs=require('node:fs');fs.appendFileSync(${JSON.stringify(calls)},process.argv[2]+String.fromCharCode(10));if(process.argv.includes('--version'))console.log('1.3.5');else if(process.argv.includes('--help'))console.error('--input-format --output-format stream-json --conversation models');else if(process.argv.includes('models')){console.error('Fetching models...');console.log('native-model\tNative Model');}\n`, { mode: 0o755 });+ expect(await probeAgy(file, false)).toEqual({ status: "healthy", version: "1.3.5" });+ expect(readFileSync(calls, "utf8")).toBe("--version\n--help\n");+ expect(await probeAgy(file, true)).toMatchObject({ status: "healthy", reasoning: { models: [{ id: "native-model", displayName: "Native Model" }] } });+ expect(readFileSync(calls, "utf8")).toBe("--version\n--help\n--version\n--help\nmodels\n");+ });+})diff --git a/src/daemon/agent-driver/src/adapters/agy/probe.ts b/src/daemon/agent-driver/src/adapters/agy/probe.tsindex cdaf0e8be..8a0566d16 100644--- a/src/daemon/agent-driver/src/adapters/agy/probe.ts+++ b/src/daemon/agent-driver/src/adapters/agy/probe.ts@@ -1,6 +1,8 @@import { existsSync } from "node:fs";import { homedir } from "node:os";import { join } from "node:path";+import type { RuntimeReasoningCatalog } from "../../contract.js";+import { normalizeRuntimeModelId, RUNTIME_MODEL_CATALOG_MAX } from "../../internal/modelCatalog.js";import type { ProbeResult } from "../../internal/adapter.js";import { killProcessTree, spawnAgentProcess } from "../../internal/killTree.js";import { probeCommandVersion, resolveCommandOnPath, resolveSpawnSpec, type ProbeDeps } from "../../internal/probe.js";@@ -14,28 +16,54 @@ export function agySpawnSpec(command?: string, deps: ProbeDeps = {}, platform =return resolveSpawnSpec("agy", [], selected, deps, platform);}-export async function probeAgy(command?: string): Promise<ProbeResult> {- const spec = agySpawnSpec(command);- const version = probeCommandVersion(spec.command);- if (!version.ok) return { status: "unhealthy", lastError: version.error };- const child = spawnAgentProcess(spec.command, ["--help"], { cwd: process.cwd(), env: { ...process.env, CI: "1" }, shell: spec.shell, stdin: "ignore" });+export function parseAgyModelCatalog(output: string): RuntimeReasoningCatalog | undefined {+ const models: RuntimeReasoningCatalog["models"][number][] = [];+ const seen = new Set<string>();+ for (const line of output.split(/\r?\n/)) {+ const match = line.match(/^(\S+)\t+(.+)$/);+ const id = normalizeRuntimeModelId(match?.[1]);+ const displayName = match?.[2]?.trim();+ if (!id || !displayName || seen.has(id)) continue;+ if (models.length === RUNTIME_MODEL_CATALOG_MAX) break;+ seen.add(id);+ models.push({ id, displayName: displayName.slice(0, 256), supportedReasoningEfforts: [] });+ }+ return models.length ? { updateMode: "unsupported", models } : undefined;+}++async function readAgyCommand(spec: ReturnType<typeof agySpawnSpec>, args: string[], includeStderr: boolean): Promise<string> {+ const child = spawnAgentProcess(spec.command, args, { cwd: process.cwd(), env: { ...process.env, CI: "1", AGY_CLI_DISABLE_AUTO_UPDATE: "true" }, shell: spec.shell, stdin: "ignore" });try {- const help = await new Promise<string>((resolve, reject) => {+ return await new Promise<string>((resolve, reject) => {let output = "";- const timer = setTimeout(() => reject(new Error("timeout")), 3_000);- const fail = () => { clearTimeout(timer); reject(new Error("help failed")); };+ const timer = setTimeout(() => reject(new Error("timeout")), includeStderr ? 5_000 : 30_000);+ const fail = () => { clearTimeout(timer); reject(new Error("command failed")); };const collect = (chunk: { toString(): string }) => {output += chunk.toString();- if (Buffer.byteLength(output) > 64 * 1024) fail();+ if (Buffer.byteLength(output) > (includeStderr ? 64 * 1024 : 1024 * 1024)) fail();};child.stdout?.on("data", collect);- child.stderr?.on("data", collect);+ child.stderr?.on("data", includeStderr ? collect : () => {});child.on("error", fail);child.on("close", (code) => { clearTimeout(timer); if (code === 0) resolve(output); else fail(); });});- return ["--input-format", "--output-format", "stream-json", "--conversation"].every((flag) => help.includes(flag))- ? { status: "healthy", version: version.version }- : { status: "unhealthy", version: version.version, lastError: "agy_stream_incompatible" };- } catch { return { status: "unhealthy", version: version.version, lastError: "agy_stream_probe_failed" }; }- finally { if (child.pid) await killProcessTree(child.pid, { graceMs: 100 }); }+ } finally { if (child.pid) await killProcessTree(child.pid, { graceMs: 100 }); }+}++export async function probeAgy(command?: string, includeModels = false): Promise<ProbeResult> {+ const spec = agySpawnSpec(command);+ const version = probeCommandVersion(spec.command);+ if (!version.ok) return { status: "unhealthy", lastError: version.error };+ let help: string;+ try { help = await readAgyCommand(spec, ["--help"], true); }+ catch { return { status: "unhealthy", version: version.version, lastError: "agy_stream_probe_failed" }; }+ if (!["--input-format", "--output-format", "stream-json", "--conversation"].every((flag) => help.includes(flag))) {+ return { status: "unhealthy", version: version.version, lastError: "agy_stream_incompatible" };+ }+ if (!includeModels || !/\bmodels\b/.test(help)) return { status: "healthy", version: version.version };+ try {+ const reasoning = parseAgyModelCatalog(await readAgyCommand(spec, ["models"], false));+ return reasoning ? { status: "healthy", version: version.version, reasoning }+ : { status: "unhealthy", version: version.version, lastError: "agy_model_catalog_invalid" };+ } catch { return { status: "unhealthy", version: version.version, lastError: "agy_model_probe_failed" }; }}diff --git a/src/daemon/agent-driver/src/adapters/antigravity/index.test.ts b/src/daemon/agent-driver/src/adapters/antigravity/index.test.tsindex b5f3edc68..87fd41545 100644--- a/src/daemon/agent-driver/src/adapters/antigravity/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/antigravity/index.test.ts@@ -1,7 +1,8 @@import { EventEmitter } from "node:events";import { PassThrough } from "node:stream";-import { mkdtempSync, rmSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";+import { existsSync, mkdtempSync, rmSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";import { tmpdir } from "node:os";+import * as os from "node:os";import { join } from "node:path";import { afterEach, describe, expect, it, vi } from "vitest";import type { AdapterEvent, SpawnedProcessHandle } from "../../internal/adapter.js";@@ -11,6 +12,11 @@ import { AntigravityDriver } from "./index.js";import { AntigravityAcpLane } from "./acp-lane.js";import { antigravitySpawnSpec, probeAntigravity } from "./probe.js";+vi.mock("node:os", async (importOriginal) => {+ const actual = await importOriginal<typeof import("node:os")>();+ return { ...actual, homedir: vi.fn(actual.homedir) };+});+type Message = { id: number; method?: string; params?: Record<string, unknown>; result?: unknown; error?: unknown };const dirs: string[] = [];afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }); });@@ -61,6 +67,35 @@ function setup(options: { authError?: boolean; loadId?: string; loadError?: bool}describe("Antigravity native ACP", () => {+ it("keeps the public driver's default native catalog and isolates installation probes from cache state", async () => {+ const nativeProbe = probeModule.probeAntigravity;+ for (const includeModels of [false, true]) {+ const h = setup();+ const home = vi.mocked(os.homedir);+ const previousHome = home.getMockImplementation()!;+ home.mockReturnValue(h.directory);+ const probe = vi.spyOn(probeModule, "probeAntigravity").mockImplementation((command, options = {}) => nativeProbe(command, {+ ...options, spawn: (() => h.proc) as never, cleanup: async () => { h.proc.kill(); },+ }));+ try {+ const driver = new AntigravityDriver();+ const result = includeModels ? await driver.probe("/custom/agy_acp_server.par") : await driver.probe("/custom/agy_acp_server.par", false);+ expect(result).toMatchObject({ status: "healthy", version: "1.3.0" });+ expect(h.messages.map((message) => message.method)).toEqual(includeModels ? ["initialize", "session/new"] : ["initialize"]);+ expect(result.reasoning?.models.map((model) => model.id)).toEqual(includeModels ? ["test-model"] : undefined);+ expect(existsSync(join(h.directory, ".cache", "alook", "antigravity-probe"))).toBe(includeModels);+ } finally { probe.mockRestore(); home.mockImplementation(previousHome); }+ }+ });++ it("accepts an identified compatible startup handshake without an optional version", async () => {+ const h = setup();+ h.proc.stdin.removeAllListeners("data");+ h.proc.stdin.on("data", () => h.emit({ id: 1, result: { protocolVersion: 1, agentInfo: { name: "antigravity-acp" }, agentCapabilities: { loadSession: true } } }));+ expect(await probeAntigravity("/custom/agy_acp_server.par", {+ includeModels: false, cacheDirectory: h.directory, spawn: (() => h.proc) as never, cleanup: async () => { h.proc.kill(); },+ })).toEqual({ status: "healthy" });+ });it("reuses one process and exact session across prompts, delivering current instructions once", async () => {const h = setup();await expect(h.lane.start({ text: "first" })).resolves.toMatchObject({ ok: true, acceptedAs: "prompt" });@@ -185,7 +220,18 @@ describe("Antigravity native ACP", () => {await expect(h.lane.send({ text: "later", mode: "idle" })).resolves.toMatchObject({ ok: false, reason: "closed" });});- it("probes the native catalog without prompting or launching interactive auth", async () => {+ it("checks installation with initialize only, even with a cached session", async () => {+ const h = setup({ authError: true });+ const cleanup = vi.fn(async () => { h.proc.kill(); });+ writeFileSync(join(h.directory, "session"), "saved-session");+ expect(await probeAntigravity("/custom/agy_acp_server.par", {+ includeModels: false, cacheDirectory: h.directory, spawn: (() => h.proc) as never, cleanup,+ })).toEqual({ status: "healthy", version: "1.3.0" });+ expect(h.messages.map((message) => message.method)).toEqual(["initialize"]);+ expect(cleanup).toHaveBeenCalledTimes(1);+ });++ it("requests the native catalog without issuing prompt or authenticate RPCs", async () => {const h = setup();const cleanup = vi.fn(async () => { h.proc.kill(); });expect(await probeAntigravity("/custom/agy_acp_server.par", { cacheDirectory: h.directory, spawn: (() => h.proc) as never, cleanup })).toMatchObject({ status: "healthy", version: "1.3.0", reasoning: { models: [{ id: "test-model" }] } });diff --git a/src/daemon/agent-driver/src/adapters/antigravity/index.ts b/src/daemon/agent-driver/src/adapters/antigravity/index.tsindex d28f28a4b..d494212ab 100644--- a/src/daemon/agent-driver/src/adapters/antigravity/index.ts+++ b/src/daemon/agent-driver/src/adapters/antigravity/index.ts@@ -16,8 +16,10 @@ export class AntigravityDriver implements BackendAdapter {terminalOwnership: "transport_request",} as const;- probe(command?: string) {- return probeAntigravity(command);+ probe(command?: string, includeModels = true) {+ return includeModels+ ? probeAntigravity(command)+ : probeAntigravity(command, { includeModels: false });}async openLane(ctx: AdapterLaunchContext, options?: RuntimeLaneOpenOptions) {diff --git a/src/daemon/agent-driver/src/adapters/antigravity/probe.ts b/src/daemon/agent-driver/src/adapters/antigravity/probe.tsindex 4eb57c721..3d07673f7 100644--- a/src/daemon/agent-driver/src/adapters/antigravity/probe.ts+++ b/src/daemon/agent-driver/src/adapters/antigravity/probe.ts@@ -13,6 +13,7 @@ export function antigravitySpawnSpec(command?: string, platform = process.platfo}type ProbeOptions = {+ includeModels?: boolean;timeoutMs?: number;cacheDirectory?: string;spawn?: typeof spawnAgentProcess;@@ -21,11 +22,14 @@ type ProbeOptions = {export async function probeAntigravity(command?: string, options: ProbeOptions = {}): Promise<ProbeResult> {const spec = antigravitySpawnSpec(command);+ const includeModels = options.includeModels !== false;const identity = createHash("sha256").update(JSON.stringify([spec.command, process.env.GEMINI_HOME ?? ""])).digest("hex").slice(0, 16);- const directory = options.cacheDirectory ?? join(homedir(), ".cache", "alook", "antigravity-probe", identity);+ const directory = options.cacheDirectory ?? (includeModels+ ? join(homedir(), ".cache", "alook", "antigravity-probe", identity)+ : homedir());const cacheFile = join(directory, "session");let cachedSessionId: string | undefined;- try {+ if (includeModels) try {mkdirSync(directory, { recursive: true, mode: 0o700 });try {const value = readFileSync(cacheFile, "utf8");@@ -136,6 +140,10 @@ export async function probeAntigravity(command?: string, options: ProbeOptions =|| asRecord(result.agentInfo)?.name !== "antigravity-acp") return fail("antigravity_acp_incompatible");const reportedVersion = asRecord(result.agentInfo)?.version;version = typeof reportedVersion === "string" ? reportedVersion : undefined;+ if (!includeModels) {+ finish({ status: "healthy", ...(version ? { version } : {}) });+ continue;+ }requestSession(cachedSessionId);}});diff --git a/src/daemon/agent-driver/src/adapters/claude/index.test.ts b/src/daemon/agent-driver/src/adapters/claude/index.test.tsindex d687ba21b..047a447c5 100644--- a/src/daemon/agent-driver/src/adapters/claude/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/claude/index.test.ts@@ -34,6 +34,13 @@ describe("ClaudeDriver", () => {});});+ it("does not publish model aliases during installation-only probing", () => {+ probeClaude.mockReturnValue({ status: "healthy", version: "1.2.3" });+ expect(new ClaudeDriver().probe(undefined, false)).toMatchObject({ status: "healthy", version: "1.2.3" });+ expect(new ClaudeDriver().probe(undefined, false).reasoning).toBeUndefined();+ expect(spawnAgentProcess).not.toHaveBeenCalled();+ });+it("reports only the three stable Claude aliases after a healthy probe", () => {probeClaude.mockReturnValue({ status: "healthy", version: "1.2.3" });diff --git a/src/daemon/agent-driver/src/adapters/claude/index.ts b/src/daemon/agent-driver/src/adapters/claude/index.tsindex b10244262..b5637b5ad 100644--- a/src/daemon/agent-driver/src/adapters/claude/index.ts+++ b/src/daemon/agent-driver/src/adapters/claude/index.ts@@ -56,7 +56,7 @@ export class ClaudeDriver implements BackendAdapter {return receipt;}- probe(command?: string): ProbeResult {+ probe(command?: string, includeModels = true): ProbeResult {const explicit = command?.trim();const base: ProbeResult = explicit? (() => {@@ -66,7 +66,7 @@ export class ClaudeDriver implements BackendAdapter {: { status: "unhealthy", lastError: result.error };})(): probeClaude();- return base.status === "healthy"+ return base.status === "healthy" && includeModels? { ...base, reasoning: CLAUDE_MODEL_CATALOG }: base;}diff --git a/src/daemon/agent-driver/src/adapters/codex/index.test.ts b/src/daemon/agent-driver/src/adapters/codex/index.test.tsindex 344fbeeed..9b72e62ca 100644--- a/src/daemon/agent-driver/src/adapters/codex/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/codex/index.test.ts@@ -80,6 +80,12 @@ function probingProcess(}describe("CodexDriver reasoning catalog probe", () => {+ it("checks installation without starting the catalog app-server", async () => {+ runtimeMocks.probeCliRuntime.mockResolvedValueOnce({ status: "healthy", version: "1.2.3" });+ expect(await new CodexDriver().probe(undefined, false)).toEqual({ status: "healthy", version: "1.2.3" });+ expect(runtimeMocks.spawnAgentProcess).not.toHaveBeenCalled();+ });+it("keeps an unhealthy CLI result unchanged without starting app-server", async () => {runtimeMocks.probeCliRuntime.mockResolvedValueOnce({status: "unhealthy",diff --git a/src/daemon/agent-driver/src/adapters/codex/index.ts b/src/daemon/agent-driver/src/adapters/codex/index.tsindex a4529d2d3..b8f71b160 100644--- a/src/daemon/agent-driver/src/adapters/codex/index.ts+++ b/src/daemon/agent-driver/src/adapters/codex/index.ts@@ -133,13 +133,14 @@ export class CodexDriver implements BackendAdapter {return this.codexHomeRoot;}- async probe(command?: string) {+ async probe(command?: string, includeModels = true) {// probeCliRuntime spawns `--version` — a missing vendored binary (npm// package resolves but the aarch64 blob is absent) fails there even// though resolveCommandOnPath returned a JS wrapper; probing the resolved// command keeps runtime health tied to what can actually execute.const result = await probeCliRuntime("codex", {}, command);if (result.status !== "healthy") return result;+ if (!includeModels) return result;return {...result,reasoning: await this.probeReasoningCatalog(command),diff --git a/src/daemon/agent-driver/src/adapters/cursor/index.test.ts b/src/daemon/agent-driver/src/adapters/cursor/index.test.tsindex 63179fc8e..a1eaed6c0 100644--- a/src/daemon/agent-driver/src/adapters/cursor/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/cursor/index.test.ts@@ -194,6 +194,13 @@ afterEach(() => {});describe("CursorDriver persistent ACP transport", () => {+ it("skips native catalog creation during installation checks", async () => {+ const catalogProbe = vi.fn();+ expect(await new CursorDriver(catalogProbe).probe(process.execPath, false)).toMatchObject({ status: "healthy" });+ expect(catalogProbe).not.toHaveBeenCalled();+ expect(spawned).toEqual([]);+ });+it("uses the ACP session/new probe for a non-fatal startup catalog", async () => {const catalogProbe = vi.fn(async () => ({updateMode: "unsupported" as const,diff --git a/src/daemon/agent-driver/src/adapters/cursor/index.ts b/src/daemon/agent-driver/src/adapters/cursor/index.tsindex 6c5d5b80c..f06dbcf21 100644--- a/src/daemon/agent-driver/src/adapters/cursor/index.ts+++ b/src/daemon/agent-driver/src/adapters/cursor/index.ts@@ -44,9 +44,10 @@ export class CursorDriver implements BackendAdapter, CursorAcpProcessFactory {private readonly catalogProbe: (command?: string) => Promise<RuntimeReasoningCatalog | undefined> = probeCursorAcpCatalog,) {}- async probe(command?: string) {+ async probe(command?: string, includeModels = true) {const result = probeCliRuntime("cursor-agent", {}, command);if (result.status !== "healthy") return result;+ if (!includeModels) return result;let reasoning: RuntimeReasoningCatalog | undefined;try {reasoning = await this.catalogProbe(command);diff --git a/src/daemon/agent-driver/src/adapters/grok/catalog-probe.ts b/src/daemon/agent-driver/src/adapters/grok/catalog-probe.tsindex cf27020db..63b83bf3e 100644--- a/src/daemon/agent-driver/src/adapters/grok/catalog-probe.ts+++ b/src/daemon/agent-driver/src/adapters/grok/catalog-probe.ts@@ -21,6 +21,7 @@ type ProbeSpawn = () => SpawnedProcessHandle;interface GrokAcpCatalogProbeOptions {+ readonly includeModels?: boolean;readonly cwd?: string;readonly timeoutMs?: number;readonly outputMaxBytes?: number;@@ -211,6 +212,7 @@ export async function probeGrokAcpCatalog(}return finish({ status: "unhealthy", lastError: "grok_acp_cached_auth_unsupported" });}+ if (options.includeModels === false) return finish({ status: "compatible" });catalog = catalogFromInitialize(result) ?? catalog;expectedId = 2;write("authenticate", { methodId: AUTH_METHOD_ID }, expectedId);diff --git a/src/daemon/agent-driver/src/adapters/grok/index.test.ts b/src/daemon/agent-driver/src/adapters/grok/index.test.tsindex 75fd44f6a..897398eb0 100644--- a/src/daemon/agent-driver/src/adapters/grok/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/grok/index.test.ts@@ -111,6 +111,18 @@ describe("Grok ACP model catalog", () => {});});+ it("validates protocol without authenticating or reading an advertised catalog at startup", async () => {+ const methods: string[] = [];+ const cleanup = vi.fn(async () => {});+ const process = fakeProcess((proc, message) => {+ methods.push(message.method as string);+ respond(proc, message, { protocolVersion: 1, agentCapabilities: { loadSession: true }, authMethods: [{ id: "cached_token" }], _meta: { modelState } });+ });+ expect(await probeGrokAcpCatalog(undefined, { includeModels: false, spawn: () => process, cleanup })).toEqual({ status: "compatible" });+ expect(methods).toEqual(["initialize"]);+ expect(cleanup).toHaveBeenCalledTimes(1);+ });+it("uses only initialize/authenticate, never creates a session, and cleans exactly once", async () => {const messages: Record<string, unknown>[] = [];const cleanup = vi.fn(async () => {});@@ -392,6 +404,12 @@ describe("GrokDriver launch boundary", () => {}));});+ it("asks for protocol-only probing during installation discovery", async () => {+ const catalogProbe = vi.fn(async () => ({ status: "compatible" as const }));+ expect(await new GrokDriver(catalogProbe).probe(process.execPath, false)).toMatchObject({ status: "healthy", reasoning: undefined });+ expect(catalogProbe).toHaveBeenCalledExactlyOnceWith(process.execPath, { includeModels: false });+ });+it("requires an authenticated compatible ACP probe before reporting healthy", async () => {const catalog = parseGrokModelCatalog(modelState);const success = vi.fn(async () => ({ status: "compatible" as const, reasoning: catalog }));diff --git a/src/daemon/agent-driver/src/adapters/grok/index.ts b/src/daemon/agent-driver/src/adapters/grok/index.tsindex 57a2aecae..a72e98b80 100644--- a/src/daemon/agent-driver/src/adapters/grok/index.ts+++ b/src/daemon/agent-driver/src/adapters/grok/index.ts@@ -35,16 +35,18 @@ export class GrokDriver implements BackendAdapter, GrokAcpProcessFactory {}constructor(- private readonly catalogProbe: (command?: string) => Promise<GrokAcpProbeResult> = probeGrokAcpCatalog,+ private readonly catalogProbe: (command?: string, options?: { includeModels?: boolean }) => Promise<GrokAcpProbeResult> = probeGrokAcpCatalog,private readonly spawnProcess: GrokSpawn = spawnAgentProcess,) {}- async probe(command?: string) {+ async probe(command?: string, includeModels = true) {const result = probeCliRuntime("grok", {}, command);if (result.status !== "healthy") return result;let acpProbe: GrokAcpProbeResult;try {- acpProbe = await this.catalogProbe(command);+ acpProbe = includeModels+ ? await this.catalogProbe(command)+ : await this.catalogProbe(command, { includeModels: false });} catch {acpProbe = { status: "unhealthy", lastError: "grok_acp_probe_failed" };}diff --git a/src/daemon/agent-driver/src/adapters/opencode/index.test.ts b/src/daemon/agent-driver/src/adapters/opencode/index.test.tsindex 37e01df05..f05b8d0a2 100644--- a/src/daemon/agent-driver/src/adapters/opencode/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/opencode/index.test.ts@@ -54,6 +54,13 @@ describe("OpenCodeDriver persistent v2 service", () => {expect(discover).toHaveBeenCalledWith(request, { compatibility: resolveOpenCodeCompatibility("2.0.28") });});+ it("checks native compatibility without querying models", () => {+ const output = vi.fn();+ expect(new OpenCodeDriver(output, () => ({ status: "healthy", version: "2.0.28" })).probe("native", false)).toMatchObject({ status: "healthy", version: "2.0.28" });+ expect(output).not.toHaveBeenCalled();+ expect(new OpenCodeDriver(output, () => ({ status: "healthy", version: "9.0.0" })).probe("native", false)).toMatchObject({ status: "unhealthy", lastError: "unsupported_opencode_cli_version" });+ });+it("uses models --pure output for a non-fatal startup catalog", () => {const outputProbe = vi.fn(() => ({ok: true as const,diff --git a/src/daemon/agent-driver/src/adapters/opencode/index.ts b/src/daemon/agent-driver/src/adapters/opencode/index.tsindex 76132a913..671da7bd7 100644--- a/src/daemon/agent-driver/src/adapters/opencode/index.ts+++ b/src/daemon/agent-driver/src/adapters/opencode/index.ts@@ -58,7 +58,7 @@ export class OpenCodeDriver implements BackendAdapter, OpenCodeServiceProcessFacreturn discoverOpenCodeRecentContext(request, { compatibility: resolveOpenCodeCompatibility(result.version) });}- probe(command?: string) {+ probe(command?: string, includeModels = true) {const result = this.versionProbe("opencode", {}, command);if (result.status !== "healthy") return result;let compatibility: OpenCodeCompatibility;@@ -67,6 +67,7 @@ export class OpenCodeDriver implements BackendAdapter, OpenCodeServiceProcessFac} catch {return { ...result, status: "unhealthy" as const, lastError: "unsupported_opencode_cli_version" };}+ if (!includeModels) return result;const spec = resolveSpawnSpec("opencode", [...compatibility.modelArgs], command);const output = this.outputProbe(spec.command, spec.args);return {diff --git a/src/daemon/agent-driver/src/adapters/pi/index.test.ts b/src/daemon/agent-driver/src/adapters/pi/index.test.tsindex 3fbc15acf..fde79ff94 100644--- a/src/daemon/agent-driver/src/adapters/pi/index.test.ts+++ b/src/daemon/agent-driver/src/adapters/pi/index.test.ts@@ -57,6 +57,12 @@ describe("PiDriver startup model catalog", () => {}) as unknown as PiSdkModule;}+ it("checks the SDK version without loading authenticated model state", async () => {+ const loadSdk = vi.fn();+ expect(await new PiDriver(undefined, loadSdk, () => "1.2.3").probe(undefined, false)).toEqual({ status: "healthy", version: "1.2.3" });+ expect(loadSdk).not.toHaveBeenCalled();+ });+it("uses authenticated ModelRuntime.getAvailable and formats provider/id", async () => {const getAvailable = vi.fn(() => [{ provider: "google", id: "gemini-2.5-pro" },@@ -77,6 +83,50 @@ describe("PiDriver startup model catalog", () => {});});+ it("uses current native registry exports without requiring ModelRuntime", async () => {+ const authStorage = {};+ const createAuth = vi.fn(() => authStorage);+ const getAvailable = vi.fn(() => [{ provider: "openai", id: "gpt-5" }]);+ const createRegistry = vi.fn(() => ({ getAvailable }));+ const loadSdk = async () => ({+ AuthStorage: { create: createAuth },+ ModelRegistry: { create: createRegistry },+ }) as unknown as PiSdkModule;++ expect(await new PiDriver(undefined, loadSdk, () => "0.80.3").probe()).toEqual({+ status: "healthy",+ version: "0.80.3",+ reasoning: { updateMode: "unsupported", models: [{ id: "openai/gpt-5", supportedReasoningEfforts: [] }] },+ });+ expect(createAuth).toHaveBeenCalledOnce();+ expect(createRegistry).toHaveBeenCalledExactlyOnceWith(authStorage);+ expect(getAvailable).toHaveBeenCalledOnce();+ });++ it("retains the legacy path when registry auth exports are incomplete", async () => {+ const createRegistry = vi.fn();+ const getAvailable = vi.fn(() => [{ provider: "google", id: "gemini-2.5-pro" }]);+ const loadSdk = async () => ({+ ...await loader(getAvailable)(),+ ModelRegistry: { create: createRegistry },+ });++ expect((await new PiDriver(undefined, loadSdk, () => "1.2.3").probe()).reasoning?.models)+ .toEqual([{ id: "google/gemini-2.5-pro", supportedReasoningEfforts: [] }]);+ expect(getAvailable).toHaveBeenCalledOnce();+ expect(createRegistry).not.toHaveBeenCalled();+ });++ it("keeps the health policy when current registry creation fails", async () => {+ const loadSdk = async () => ({+ AuthStorage: { create: vi.fn() },+ ModelRegistry: { create: () => { throw new Error("registry failed"); } },+ }) as unknown as PiSdkModule;++ expect(await new PiDriver(undefined, loadSdk, () => "0.80.3").probe())+ .toEqual({ status: "healthy", version: "0.80.3", reasoning: undefined });+ });+it("keeps runtime health healthy when SDK catalog discovery fails", async () => {const result = await new PiDriver(undefined,diff --git a/src/daemon/agent-driver/src/adapters/pi/index.ts b/src/daemon/agent-driver/src/adapters/pi/index.tsindex 532ee6167..ca8374956 100644--- a/src/daemon/agent-driver/src/adapters/pi/index.ts+++ b/src/daemon/agent-driver/src/adapters/pi/index.ts@@ -271,7 +271,7 @@ export class PiDriver implements BackendAdapter {private readonly readVersion: () => string | undefined = readPiSdkVersion,) {}- async probe() {+ async probe(_command?: string, includeModels = true) {const version = this.readVersion();if (!version) {// The Pi SDK is a native runtime — no CLI to spawn. If the npm module@@ -279,11 +279,14 @@ export class PiDriver implements BackendAdapter {// reflects reality and the bot picker filters it out.return { status: "unhealthy" as const, lastError: "sdk_not_installed" };}+ if (!includeModels) return { status: "healthy" as const, version };let timer: ReturnType<typeof setTimeout> | undefined;try {const reasoning = await Promise.race([this.loadSdk().then(async (sdk) => {- const modelRuntime = await sdk.ModelRuntime.create();+ const modelRuntime = sdk.ModelRegistry && sdk.AuthStorage+ ? sdk.ModelRegistry.create(sdk.AuthStorage.create())+ : await sdk.ModelRuntime.create();return parsePiModelCatalog(await modelRuntime.getAvailable());}),new Promise<undefined>((resolve) => {diff --git a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.tsindex 087980b29..fbd8b4f97 100644--- a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts+++ b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts@@ -17,6 +17,8 @@ const PI_SDK_PACKAGE_NAME = "@earendil-works/pi-coding-agent";/** The slice of the vendor SDK's module exports this file actually calls. */export interface PiSdkModule {ModelRuntime: { create(): Promise<PiModelRuntime> };+ AuthStorage?: { create(): unknown };+ ModelRegistry?: { create(authStorage: unknown): { getAvailable(): readonly unknown[] | Promise<readonly unknown[]> } };SessionManager: {create(cwd: string, sessionDir?: string, options?: { id?: string }): unknown;open(path: string, sessionDir?: string, cwdOverride?: string): unknown;diff --git a/src/daemon/agent-driver/src/contract.ts b/src/daemon/agent-driver/src/contract.tsindex f9f19c95c..dd98afaf9 100644--- a/src/daemon/agent-driver/src/contract.ts+++ b/src/daemon/agent-driver/src/contract.ts@@ -575,6 +575,7 @@ export interface AgentSession<Specs, Id extends BackendId<Specs>> {export interface ProbeInput<Specs, Id extends BackendId<Specs>> {readonly backend: Id;readonly command?: string;+ readonly includeModels?: boolean;}export interface DiscoveredSessionFile {diff --git a/src/daemon/agent-driver/src/internal/adapter.ts b/src/daemon/agent-driver/src/internal/adapter.tsindex e4c3cb3f3..0bcef844a 100644--- a/src/daemon/agent-driver/src/internal/adapter.ts+++ b/src/daemon/agent-driver/src/internal/adapter.ts@@ -208,7 +208,7 @@ export interface BackendAdapter<Id extends string = BuiltinBackendId, Config = B| { readonly kind: "native" }| { readonly kind: "workspace_file"; readonly canonical: string; readonly aliases: readonly string[] };readonly execution: BackendExecution;- probe(command?: string): ProbeResult | Promise<ProbeResult>;+ probe(command?: string, includeModels?: boolean): ProbeResult | Promise<ProbeResult>;discoverRecentContext?(input: RecentContextDiscoveryRequest): Promise<RecentContextDiscoveryData>;openLane(ctx: AdapterLaunchContext<Id, Config>,diff --git a/src/daemon/agent-driver/src/sdk.test.ts b/src/daemon/agent-driver/src/sdk.test.tsindex c6a92a52c..14f4c2ebb 100644--- a/src/daemon/agent-driver/src/sdk.test.ts+++ b/src/daemon/agent-driver/src/sdk.test.ts@@ -62,6 +62,15 @@ describe("createAgentDriverSdk", () => {expect(SESSION_FILE_DISCOVERY_CAPABILITIES).toEqual(["supported", "unavailable"]);});+ it("passes installation-only intent while preserving the full default probe", async () => {+ const probe = vi.spyOn(ClaudeDriver.prototype, "probe").mockReturnValue({ status: "healthy", version: "1.2.3" });+ const sdk = createAgentDriverSdk();+ await sdk.probe({ backend: "claude", includeModels: false });+ expect(probe).toHaveBeenLastCalledWith(undefined, false);+ await sdk.probe({ backend: "claude" });+ expect(probe).toHaveBeenLastCalledWith(undefined);+ });+it("maps healthy, unhealthy, and thrown adapter probes", async () => {const sdk = createAgentDriverSdk();const probe = vi.spyOn(ClaudeDriver.prototype, "probe");diff --git a/src/daemon/agent-driver/src/sdk.ts b/src/daemon/agent-driver/src/sdk.tsindex 49311aa8b..15755002d 100644--- a/src/daemon/agent-driver/src/sdk.ts+++ b/src/daemon/agent-driver/src/sdk.ts@@ -110,7 +110,9 @@ export function createAgentDriverSdkWithRegistry<Specs>(const command = (capabilities as { readonly commandOverride: boolean }).commandOverride? input.command: undefined;- const result = await adapter.probe(command);+ const result = input.includeModels === false+ ? await adapter.probe(command, false)+ : await adapter.probe(command);if (result.status === "healthy") {return {status: "healthy",diff --git a/src/daemon/src/drivers/index.test.ts b/src/daemon/src/drivers/index.test.tsnew file mode 100644index 000000000..1b3c76167--- /dev/null+++ b/src/daemon/src/drivers/index.test.ts@@ -0,0 +1,25 @@+import { beforeEach, describe, expect, it, vi } from "vitest";+import { BUILTIN_BACKEND_IDS, getBuiltinBackendCapabilities } from "@alook/agent-driver";+import { getDriver } from "./index";++const probe = vi.hoisted(() => vi.fn());+vi.mock("@alook/agent-driver", async (importOriginal) => {+ const actual = await importOriginal<typeof import("@alook/agent-driver")>();+ return { ...actual, createAgentDriverSdk: () => ({ probe }) };+});+beforeEach(() => probe.mockReset());++describe("daemon runtime probe intent", () => {+ it.each(BUILTIN_BACKEND_IDS)("separates %s installation from its native catalog without altering metadata", async (id) => {+ const catalog = { updateMode: "unsupported" as const, defaultModelId: "native", models: [{ id: "native", supportedReasoningEfforts: [{ value: "high", label: "High" }] }] };+ const installed = { status: "healthy", version: "native", capabilities: getBuiltinBackendCapabilities(id) };+ const discovered = { ...installed, reasoning: catalog };+ probe.mockResolvedValueOnce(installed).mockResolvedValueOnce(discovered);+ const driver = getDriver(id);+ expect(await driver.probe()).toBe(installed);+ expect(probe).toHaveBeenNthCalledWith(1, { backend: id, includeModels: false });+ expect(await driver.discoverModels()).toBe(discovered);+ expect(probe).toHaveBeenNthCalledWith(2, { backend: id });+ expect(driver.capabilities).toEqual(installed.capabilities);+ });+});diff --git a/src/daemon/src/drivers/index.ts b/src/daemon/src/drivers/index.tsindex 44e6709f1..21ae8babb 100644--- a/src/daemon/src/drivers/index.ts+++ b/src/daemon/src/drivers/index.ts@@ -13,6 +13,7 @@ export interface AgentBackend {readonly id: RuntimeId;readonly capabilities: BackendCapabilities;probe(): Promise<BackendProbe<BackendCapabilities>>;+ discoverModels(): Promise<BackendProbe<BackendCapabilities>>;}export function getDriver(runtimeId: string): AgentBackend {@@ -23,7 +24,8 @@ export function getDriver(runtimeId: string): AgentBackend {return {id,capabilities: getBuiltinBackendCapabilities(id),- probe: () => createAgentDriverSdk().probe({ backend: id }),+ probe: () => createAgentDriverSdk().probe({ backend: id, includeModels: false }),+ discoverModels: () => createAgentDriverSdk().probe({ backend: id }),};}diff --git a/src/daemon/src/manager/agentRouter.test.ts b/src/daemon/src/manager/agentRouter.test.tsindex 1aab4d867..c13f5c8e1 100644--- a/src/daemon/src/manager/agentRouter.test.ts+++ b/src/daemon/src/manager/agentRouter.test.ts@@ -1298,3 +1298,133 @@ describe("AgentRouter — bot typing indicator", () => {expect(tracker.hasAny("bot_1")).toBe(false);});});+++describe("AgentRouter model discovery", () => {+ it("queries only the selected runtime, updates ready catalog and never wakes a bot", async () => {+ const { mgr, delivers, registers } = fakeManager();+ const { ch, fire, readys } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ const reasoning = { updateMode: "unsupported" as const, models: [{ id: "native-model", supportedReasoningEfforts: [] }] };+ const discoverModels = vi.fn().mockResolvedValue({ status: "healthy", version: "2", reasoning });+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex", version: "1" }, { id: "claude" }], discoverModels });+ await router.start();+ expect(readys[0]?.capabilities).toContain("runtime-model-discovery-v1");+ await fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "request-1" });+ expect(discoverModels).toHaveBeenCalledExactlyOnceWith("codex");+ expect(report).toHaveBeenCalledWith(expect.objectContaining({ type: "runtime_models", runtimeId: "codex", requestId: "request-1", result: { status: "complete", runtimeReport: [expect.objectContaining({ id: "codex", version: "1", reasoning }), expect.objectContaining({ id: "claude" })] } }));+ expect(delivers).toEqual([]);+ expect(registers).toEqual([]);+ expect(router.buildReady().runtimeReport[0]?.reasoning).toEqual(reasoning);+ });+ it("keeps runtime health on catalog failure and correlates unknown-runtime errors", async () => {+ const { mgr } = fakeManager();+ const { ch, fire } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ const discoverModels = vi.fn().mockResolvedValue({ status: "unhealthy", error: { code: "auth_required", message: "Sign in to the native runtime" } });+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex", status: "healthy" }], discoverModels });+ await router.start();+ await fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "request-2" });+ expect(report).toHaveBeenLastCalledWith(expect.objectContaining({ requestId: "request-2", result: { status: "error", code: "auth_required", message: "Sign in to the native runtime" } }));+ expect(router.buildReady().runtimeReport).toEqual([expect.objectContaining({ id: "codex", status: "healthy" })]);+ await fire({ type: "runtime:discover_models", runtimeId: "missing", requestId: "request-3" });+ expect(discoverModels).toHaveBeenCalledTimes(1);+ expect(report).toHaveBeenLastCalledWith(expect.objectContaining({ requestId: "request-3", result: expect.objectContaining({ status: "error" }) }));+ });+});+++describe("model discovery deadline", () => {+ it("ends loading at 40 seconds and ignores a late catalog", async () => {+ vi.useFakeTimers();+ try {+ const { mgr } = fakeManager();+ const { ch, fire } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ let complete!: (value: unknown) => void;+ const discoverModels = vi.fn(() => new Promise<any>((resolve) => { complete = resolve; }));+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex" }], discoverModels });+ await router.start();+ const request = fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "deadline" });+ await vi.advanceTimersByTimeAsync(40_000);+ await request;+ expect(report).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ requestId: "deadline", result: expect.objectContaining({ status: "error", code: "model_discovery_timeout" }) }));+ complete({ status: "healthy", reasoning: { updateMode: "unsupported", models: [{ id: "late", supportedReasoningEfforts: [] }] } });+ await Promise.resolve();+ expect(report).toHaveBeenCalledTimes(1);+ expect(router.buildReady().runtimeReport[0].reasoning).toBeUndefined();+ } finally { vi.useRealTimers(); }+ });+})+++describe("runtime model query ownership", () => {+ it("reuses one native query for overlapping requests and replies to each request ID", async () => {+ const { mgr } = fakeManager();+ const { ch, fire } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ let finish!: (value: unknown) => void;+ const discoverModels = vi.fn(() => new Promise<any>((resolve) => { finish = resolve; }));+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex" }], discoverModels });+ await router.start();+ const first = fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "A" });+ const reopened = fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "B" });+ await Promise.resolve();+ expect(discoverModels).toHaveBeenCalledExactlyOnceWith("codex");+ const reasoning = { updateMode: "unsupported", models: [{ id: "fresh", supportedReasoningEfforts: [] }] };+ finish({ status: "healthy", reasoning });+ await Promise.all([first, reopened]);+ expect(report.mock.calls.map(([frame]) => frame.requestId)).toEqual(["A", "B"]);+ const [a, b] = report.mock.calls.map(([frame]) => frame.result.runtimeReport);+ expect(a).toEqual(b);+ expect(a[0].reasoning).toEqual(reasoning);+ await fire({ type: "runtime:discover_models", runtimeId: "missing", requestId: "unknown" });+ expect(discoverModels).toHaveBeenCalledTimes(1);+ });+ it("releases a timed-out shared query, retries, and never commits the late old result", async () => {+ vi.useFakeTimers();+ try {+ const { mgr } = fakeManager();+ const { ch, fire } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ let oldFinish!: (value: unknown) => void;+ const fresh = { updateMode: "unsupported", models: [{ id: "fresh", supportedReasoningEfforts: [] }] };+ const discoverModels = vi.fn()+ .mockImplementationOnce(() => new Promise<any>((resolve) => { oldFinish = resolve; }))+ .mockResolvedValue({ status: "healthy", reasoning: fresh });+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex" }], discoverModels });+ await router.start();+ const a = fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "A" });+ const b = fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "B" });+ await vi.advanceTimersByTimeAsync(40_000);+ await Promise.all([a, b]);+ expect(discoverModels).toHaveBeenCalledTimes(1);+ expect(report.mock.calls.map(([frame]) => frame.result.code)).toEqual(["model_discovery_timeout", "model_discovery_timeout"]);+ await fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "retry" });+ expect(discoverModels).toHaveBeenCalledTimes(2);+ oldFinish({ status: "healthy", reasoning: { ...fresh, models: [{ id: "stale", supportedReasoningEfforts: [] }] } });+ await Promise.resolve();+ expect(report).toHaveBeenCalledTimes(3);+ expect(router.buildReady().runtimeReport[0].reasoning).toEqual(fresh);+ expect(report.mock.calls[2][0].result.runtimeReport[0].reasoning).toEqual(fresh);+ } finally { vi.useRealTimers(); }+ });+ it("releases a failed query so an explicit retry can succeed", async () => {+ const { mgr } = fakeManager();+ const { ch, fire } = fakeChannel();+ const report = vi.fn();+ ch.reportRuntimeModels = report;+ const discoverModels = vi.fn().mockRejectedValueOnce(new Error("native failure")).mockResolvedValue({ status: "healthy" });+ const router = new AgentRouter({ manager: mgr, channel: ch, runtimeReport: [{ id: "codex" }], discoverModels });+ await router.start();+ await fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "failure" });+ await fire({ type: "runtime:discover_models", runtimeId: "codex", requestId: "retry" });+ expect(discoverModels).toHaveBeenCalledTimes(2);+ expect(report.mock.calls.map(([frame]) => frame.result.status)).toEqual(["error", "complete"]);+ });+})diff --git a/src/daemon/src/manager/agentRouter.ts b/src/daemon/src/manager/agentRouter.tsindex 179e2389d..5097bb412 100644--- a/src/daemon/src/manager/agentRouter.ts+++ b/src/daemon/src/manager/agentRouter.ts@@ -20,11 +20,14 @@*/import type { HostCommand, HostControlChannel, HostReady, HostReadyRuntime, UnreadNotice, AgentSessionReport, SessionErrorFrame, AgentId, HostAgentActivity } from "../server/contract.js";import type { ProviderQuotaSnapshot } from "@alook/shared";-import { CONTROL_HEARTBEAT_CAPABILITY } from "../server/contract.js";+import { CONTROL_HEARTBEAT_CAPABILITY, RUNTIME_MODEL_DISCOVERY_CAPABILITY } from "../server/contract.js";+import { getDriver, type AgentBackend } from "../drivers/index.js";import type { AgentProcessManager } from "./managerRuntime.js";import type { TypingScopeTracker } from "./typingScopeTracker.js";import { createLogger, type Logger } from "../logger.js";+type ModelDiscovery = Awaited<ReturnType<AgentBackend["discoverModels"]>> | null;+const DEFINITIVE_EXECUTABLE_FAILURES = new Set(["ENOENT", "EACCES", "ENOEXEC", "EPERM"]);/**@@ -79,6 +82,7 @@ export interface AgentRouterOpts {channel: HostControlChannel;/** Runtime descriptors reported in the ready handshake. Copied into a live mutable map. */runtimeReport: HostReadyRuntime[];+ discoverModels?: (runtimeId: string) => ReturnType<AgentBackend["discoverModels"]>;hostname?: string;platform?: string;arch?: string;@@ -198,6 +202,7 @@ export class AgentRouter {* runtimes deterministically across reports.*/private readonly runtimes = new Map<string, HostReadyRuntime>();+ private readonly modelDiscoveries = new Map<string, Promise<ModelDiscovery>>();/** Coalescer: one microtask-scheduled `sendReady` per burst of mutations. */private pendingResend = false;private readonly scheduleResend: (fn: () => void) => void;@@ -246,7 +251,7 @@ export class AgentRouter {: this.opts.timeZone;return {runtimeReport: [...this.runtimes.values()],- capabilities: [CONTROL_HEARTBEAT_CAPABILITY],+ capabilities: [CONTROL_HEARTBEAT_CAPABILITY, ...(this.opts.channel.reportRuntimeModels ? [RUNTIME_MODEL_DISCOVERY_CAPABILITY] : [])],runningAgents: [...this.running],hostname: this.opts.hostname,platform: this.opts.platform,@@ -461,8 +466,53 @@ export class AgentRouter {return pending;}+ private discoverRuntimeModels(runtimeId: string): Promise<ModelDiscovery> {+ const active = this.modelDiscoveries.get(runtimeId);+ if (active) return active;+ const pending = this.runModelDiscovery(runtimeId).finally(() => this.modelDiscoveries.delete(runtimeId));+ this.modelDiscoveries.set(runtimeId, pending);+ return pending;+ }++ private async runModelDiscovery(runtimeId: string): Promise<ModelDiscovery> {+ let deadline: ReturnType<typeof setTimeout> | undefined;+ const timeout = new Promise<null>((resolve) => {+ deadline = setTimeout(() => resolve(null), 40_000);+ });+ const probe = await Promise.race([+ Promise.resolve().then(() => this.opts.discoverModels?.(runtimeId) ?? getDriver(runtimeId).discoverModels()),+ timeout,+ ]).finally(() => clearTimeout(deadline));+ if (probe?.status === "healthy") {+ this.runtimes.set(runtimeId, { ...this.runtimes.get(runtimeId)!, reasoning: probe.reasoning });+ }+ return probe;+ }+private async onCommand(cmd: HostCommand): Promise<void> {switch (cmd.type) {+ case "runtime:discover_models": {+ const reply = this.opts.channel.reportRuntimeModels;+ if (!reply) return;+ const identity = { type: "runtime_models" as const, requestId: cmd.requestId, runtimeId: cmd.runtimeId };+ try {+ const current = this.runtimes.get(cmd.runtimeId);+ if (!current) throw new UnknownRuntimeError(cmd.runtimeId, [...this.runtimes.keys()]);+ const probe = await this.discoverRuntimeModels(cmd.runtimeId);+ if (!probe) {+ reply.call(this.opts.channel, { ...identity, result: { status: "error", code: "model_discovery_timeout", message: "Model discovery timed out; retry the request" } });+ return;+ }+ if (probe.status !== "healthy") {+ reply.call(this.opts.channel, { ...identity, result: { status: "error", code: probe.error.code, message: probe.error.message } });+ return;+ }+ reply.call(this.opts.channel, { ...identity, result: { status: "complete", runtimeReport: [...this.runtimes.values()] } });+ } catch {+ reply.call(this.opts.channel, { ...identity, result: { status: "error", code: "model_discovery_failed", message: "Could not discover models for this runtime" } });+ }+ return;+ }case "agent:wake":this.log.info("agent:wake received", {agentId: cmd.agentId,diff --git a/src/daemon/src/server/contract.ts b/src/daemon/src/server/contract.tsindex e748aaa19..c8f2621cf 100644--- a/src/daemon/src/server/contract.ts+++ b/src/daemon/src/server/contract.ts@@ -78,6 +78,7 @@ export type {AgentActivityState,HostAgentActivity,HostBotAuditEventFrame,+ HostRuntimeModelsFrame,BotAuditEventPayload,WebSocketLike,WebSocketFactory,@@ -87,6 +88,8 @@ export type {ParsedRef,} from "@alook/shared/community-cli-contract";+export { RUNTIME_MODEL_DISCOVERY_CAPABILITY } from "@alook/shared/community-cli-contract";+export {CONTROL_HEARTBEAT_CAPABILITY,DM_SERVER,diff --git a/src/daemon/src/server/wsControlChannel.test.ts b/src/daemon/src/server/wsControlChannel.test.tsindex c549e0653..56c0d7182 100644--- a/src/daemon/src/server/wsControlChannel.test.ts+++ b/src/daemon/src/server/wsControlChannel.test.ts@@ -2,6 +2,7 @@ import { describe, it, expect, vi } from "vitest";import { WS_CONTROL_COMMAND_CONSUMED, WsControlChannel } from "./wsControlChannel";import type { WebSocketLike, HostReady, AgentSessionReport, HostCommand } from "./contract";import type { Logger } from "../logger";+import { HostRuntimeModelsFrameSchema } from "@alook/shared";/*** A controllable fake socket: records sent frames, lets the test drive open/close@@ -302,6 +303,18 @@ describe("WsControlChannel — auth rejection", () => {});describe("WsControlChannel — ready frame", () => {+ it("round-trips correlated native catalog and error replies over the machine socket", () => {+ const { ch, sockets } = makeChannel();+ ch.connect();+ sockets[0].emit("open");+ const frames = [+ { type: "runtime_models" as const, requestId: "catalog", runtimeId: "agy", result: { status: "complete" as const, runtimeReport: [{ id: "agy", status: "healthy" as const, reasoning: { updateMode: "unsupported" as const, models: [{ id: "native", supportedReasoningEfforts: [] }] } }] } },+ { type: "runtime_models" as const, requestId: "error", runtimeId: "agy", result: { status: "error" as const, code: "agy_model_probe_failed", message: "Could not load models" } },+ ];+ for (const frame of frames) ch.reportRuntimeModels(frame);+ expect(sockets[0].frames().filter((frame) => frame.type === "runtime_models").map((frame) => HostRuntimeModelsFrameSchema.parse(frame))).toEqual(frames);+ ch.close();+ });it("round-trips runtimeReport on the ready frame", async () => {const { ch, sockets } = makeChannel();const ready: HostReady = {diff --git a/src/daemon/src/server/wsControlChannel.ts b/src/daemon/src/server/wsControlChannel.tsindex 53770e119..bfd9e1751 100644--- a/src/daemon/src/server/wsControlChannel.ts+++ b/src/daemon/src/server/wsControlChannel.ts@@ -34,6 +34,7 @@ import type {WebSocketFactory,HostAgentActivity,HostBotAuditEventFrame,+ HostRuntimeModelsFrame,} from "./contract.js";import { HostCommandSchema } from "./contract.js";import { createLogger, type Logger } from "../logger.js";@@ -145,6 +146,7 @@ type OutboundFrame =| { type: "machine_heartbeat_ack"; nonce: string }| { type: "diagnostics_ack"; reportId: string }| HostBotAuditEventFrame+ | HostRuntimeModelsFrame| SessionErrorFrame;type ResyncProvider = () => {@@ -343,6 +345,10 @@ export class WsControlChannel implements HostControlChannel {this.sendFrame(frame);}+ reportRuntimeModels(frame: HostRuntimeModelsFrame): void {+ this.sendFrame(frame);+ }+/** Restore one completion from the timeline's durable outbox after startup. */restorePendingBotAuditEvent(frame: HostBotAuditEventFrame): void {if (!frame.eventId || !frame.occurredAt) return;diff --git a/src/shared/src/community-cli-contract.ts b/src/shared/src/community-cli-contract.tsindex 172d83b7d..65a9513da 100644--- a/src/shared/src/community-cli-contract.ts+++ b/src/shared/src/community-cli-contract.ts@@ -29,6 +29,9 @@ import { CHANNEL_TRAITS } from "./utils/community-roles";import { parseNameAndTag } from "./lib/discriminator";import { DiagnosticCollectCommandSchema } from "./diagnostics-contract";import type { DiagnosticCollectCommand } from "./diagnostics-contract";+import { RuntimeModelDiscoveryCommandSchema } from "./runtime-models-contract";+import type { RuntimeModelDiscoveryCommand, RuntimeModelDiscoveryError } from "./runtime-models-contract";+export { RUNTIME_MODEL_DISCOVERY_CAPABILITY } from "./runtime-models-contract";import type {DailyUsageSnapshot,ProviderQuotaSnapshot,@@ -773,6 +776,7 @@ export type AgentInterruptRequest = z.infer<typeof AgentInterruptRequestSchema>;*/export type HostCommand =| { type: "machine:heartbeat"; nonce: string }+ | RuntimeModelDiscoveryCommand| AgentInterruptRequest| {type: "agent:wake";@@ -996,6 +1000,13 @@ export interface HostBotAuditEventFrame {event: BotAuditEventPayload;}+export type HostRuntimeModelsFrame = {+ type: "runtime_models";+ requestId: string;+ runtimeId: string;+ result: { status: "complete"; runtimeReport: HostReadyRuntime[] } | RuntimeModelDiscoveryError;+};+/*** `session.error` frame — daemon → server. Currently used by the daemon's* agent router when a runtime isn't available on the host.@@ -1018,6 +1029,7 @@ export interface HostControlChannel {onCommand(cb: (cmd: HostCommand) => void | Promise<void>): void;/** Announce this host + its agents to the server (on connect AND on reconnect). */reportReady(ready: HostReady): Promise<void>;+ reportRuntimeModels?(frame: HostRuntimeModelsFrame): void;/*** On-demand resend of the current `ready` snapshot. Used by AgentRouter's* runtime-health mutations to push an updated report without waiting for a@@ -1475,6 +1487,7 @@ export function formatSeq(seq: Seq): string {// downstream with its own defaulting, so deep-validating it here would only turn// a forward-compatible server field into a hard drop on an older daemon.export const HostCommandSchema = z.discriminatedUnion("type", [+ RuntimeModelDiscoveryCommandSchema,z.strictObject({type: z.literal("machine:heartbeat"),nonce: z.string().min(1).max(128),diff --git a/src/shared/src/community-ws-events.ts b/src/shared/src/community-ws-events.tsindex 2950b3932..731d30002 100644--- a/src/shared/src/community-ws-events.ts+++ b/src/shared/src/community-ws-events.ts@@ -1,6 +1,6 @@import { z } from "zod"import type { CommunityContract } from "./community-contract"-import { CommunityMachineSummarySchema } from "./schemas"+import { CommunityMachineSummarySchema, RuntimeModelDiscoveryResultSchema } from "./schemas"import { FriendApprovalPayloadSchema } from "./community-friend-approval"import { CommunityChannelResourceSchema, CommunityMessageResourceSchema, CommunityMemberRelationSchema, CommunityResourceProfileSchema } from "./community-resources"@@ -441,6 +441,14 @@ const communityBotAuditEventSchema = z.strictObject({createdAt: string,}).refine((event) => Object.prototype.hasOwnProperty.call(event, "payload"))+const communityRuntimeModelsSchema = z.strictObject({+ type: z.literal("community:runtime.models"),+ machineId: z.string().min(1),+ requestId: z.string().min(1).max(128),+ runtimeId: z.string().min(1).max(64),+ result: RuntimeModelDiscoveryResultSchema,+})+const commonCommunityEventSchemas = [communityMessageUpdatedSchema,communityMessageEditedSchema,@@ -479,6 +487,7 @@ const commonCommunityEventSchemas = [communityMachineCreatedSchema,communityMachineStatusSchema,communityMachineUpdatedSchema,+ communityRuntimeModelsSchema,communityMachineRemovedSchema,communityBotAuditEventSchema,] as const@@ -584,6 +593,7 @@ export type CommunityIdentityUpdate = Extract<CommunityWsEvent, { type: "communiexport type CommunityProfileUpdate = Extract<CommunityWsEvent, { type: "community:profile.update" }>export type CommunityMachineCreated = Extract<CommunityWsEvent, { type: "community:machine.created" }>export type CommunityMachineStatus = Extract<CommunityWsEvent, { type: "community:machine.status" }>+export type CommunityRuntimeModels = Extract<CommunityWsEvent, { type: "community:runtime.models" }>export type CommunityMachineUpdated = Extract<CommunityWsEvent, { type: "community:machine.updated" }>export type CommunityMachineRemoved = Extract<CommunityWsEvent, { type: "community:machine.removed" }>export type CommunityBotAuditEvent = Extract<CommunityWsEvent, { type: "community:bot.audit_event" }>@@ -656,6 +666,7 @@ export const WS_EVENTS = {MACHINE_CREATED: "community:machine.created",MACHINE_STATUS: "community:machine.status",MACHINE_UPDATED: "community:machine.updated",+ RUNTIME_MODELS: "community:runtime.models",MACHINE_REMOVED: "community:machine.removed",BOT_AUDIT_EVENT: "community:bot.audit_event",} as const satisfies Record<string, CommunityWsEvent["type"]>diff --git a/src/shared/src/db/queries/community/machine-session-epoch.ts b/src/shared/src/db/queries/community/machine-session-epoch.tsindex 8ef52e91b..cd0eaae58 100644--- a/src/shared/src/db/queries/community/machine-session-epoch.ts+++ b/src/shared/src/db/queries/community/machine-session-epoch.ts@@ -101,7 +101,7 @@ async function transitionLiveLease(const values = command.type === "ready"? {hostname: command.metadata.hostname ?? prior.hostname,- displayName: command.metadata.hostname ?? prior.hostname,+ displayName: command.metadata.hostname !== undefined ? command.metadata.hostname : prior.displayName,platform: command.metadata.platform ?? prior.platform,arch: command.metadata.arch ?? prior.arch,osRelease: command.metadata.osRelease ?? prior.osRelease,diff --git a/src/shared/src/http-json.ts b/src/shared/src/http-json.tsnew file mode 100644index 000000000..1dc8838cc--- /dev/null+++ b/src/shared/src/http-json.ts@@ -0,0 +1,54 @@+export type BoundedHttpJsonFailure = { ok: false; reason: "oversized" | "invalid-json"; byteCount: number }+export type BoundedHttpJsonResult = { ok: true; value: unknown; byteCount: number } | BoundedHttpJsonFailure++function oversized(byteCount: number): BoundedHttpJsonFailure {+ return { ok: false, reason: "oversized", byteCount }+}++export async function readBoundedJsonRequest(+ request: Request,+ maxBytes: number,+): Promise<BoundedHttpJsonResult> {+ const contentLength = request.headers.get("content-length")+ if (contentLength !== null) {+ const declared = Number(contentLength)+ if (Number.isSafeInteger(declared) && declared > maxBytes) return oversized(declared)+ }+ const reader = request.body?.getReader()+ if (!reader) return { ok: false, reason: "invalid-json", byteCount: 0 }+ const chunks: Uint8Array[] = []+ let byteCount = 0+ try {+ while (true) {+ const { done, value } = await reader.read()+ if (done) break+ byteCount += value.byteLength+ if (byteCount > maxBytes) {+ try {+ await reader.cancel()+ } catch {}+ return oversized(byteCount)+ }+ chunks.push(value)+ }+ } catch {+ return { ok: false, reason: "invalid-json", byteCount }+ }+ const bytes = new Uint8Array(byteCount)+ let offset = 0+ for (const chunk of chunks) {+ bytes.set(chunk, offset)+ offset += chunk.byteLength+ }+ let text: string+ try {+ text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes)+ } catch {+ return { ok: false, reason: "invalid-json", byteCount }+ }+ try {+ return { ok: true, value: JSON.parse(text), byteCount }+ } catch {+ return { ok: false, reason: "invalid-json", byteCount }+ }+}diff --git a/src/shared/src/index.ts b/src/shared/src/index.tsindex 99227d7c9..760cc840f 100644--- a/src/shared/src/index.ts+++ b/src/shared/src/index.ts@@ -286,6 +286,8 @@ export {CommunityDaemonEnrollAgentRequestSchema,CommunityDaemonEnrollAgentResponseSchema,HostReadyMessageSchema,+ HostRuntimeModelsFrameSchema,+ RuntimeModelDiscoveryResultSchema,SessionErrorFrameSchema,AgentActivityMessageSchema,AgentTypingMessageSchema,@@ -828,3 +830,6 @@ export { resolveMode, cliCommand, cliPackageName, updateCommand, daemonCommand,export type { AlookMode, ModeSignals, BaseUrlSignals } from "./mode";export { COMMUNITY_CONTRACT_HEADER, COMMUNITY_CONTRACT_VERSION, COMMUNITY_RESOURCE_CONTRACT_VERSION, requestedCommunityContract, requestsCommunityContract, type CommunityContract } from "./community-contract";export * from "./community-resources";+export * from "./runtime-models-contract";++export { readBoundedJsonRequest } from "./http-json";diff --git a/src/shared/src/runtime-models-contract.ts b/src/shared/src/runtime-models-contract.tsnew file mode 100644index 000000000..0b987aa9f--- /dev/null+++ b/src/shared/src/runtime-models-contract.ts@@ -0,0 +1,25 @@+import { z } from "zod";+import type { RuntimeReasoningCatalog } from "./runtime-config";++export const RUNTIME_MODEL_DISCOVERY_CAPABILITY = "runtime-model-discovery-v1";++export const RuntimeModelDiscoveryRequestSchema = z.strictObject({+ requestId: z.string().min(1).max(128),+ runtimeId: z.string().min(1).max(64),+});+export type RuntimeModelDiscoveryRequest = z.infer<typeof RuntimeModelDiscoveryRequestSchema>;++export const RuntimeModelDiscoveryCommandSchema = RuntimeModelDiscoveryRequestSchema.extend({+ type: z.literal("runtime:discover_models"),+});+export type RuntimeModelDiscoveryCommand = z.infer<typeof RuntimeModelDiscoveryCommandSchema>;++export const RuntimeModelDiscoveryErrorSchema = z.strictObject({+ status: z.literal("error"),+ code: z.string().min(1).max(64),+ message: z.string().min(1).max(256),+});+export type RuntimeModelDiscoveryError = z.infer<typeof RuntimeModelDiscoveryErrorSchema>;+export type RuntimeModelDiscoveryResult =+ | { status: "complete"; catalog: RuntimeReasoningCatalog | null }+ | RuntimeModelDiscoveryError;diff --git a/src/shared/src/schemas.ts b/src/shared/src/schemas.tsindex 95f28f73a..f8f1e5d35 100644--- a/src/shared/src/schemas.ts+++ b/src/shared/src/schemas.ts@@ -1,3 +1,4 @@+import { RuntimeModelDiscoveryRequestSchema, RuntimeModelDiscoveryErrorSchema } from "./runtime-models-contract";import { z } from "zod";import { IssueStatus, TASK_TYPES } from "./constants";import { sanitizeSlug } from "./utils/slug";@@ -932,6 +933,19 @@ export const CommunityMachineRuntimeListSchema = zreturn out;});+export const RuntimeModelDiscoveryResultSchema = z.discriminatedUnion("status", [+ z.strictObject({ status: z.literal("complete"), catalog: RuntimeReasoningCatalogSchema.nullable() }),+ RuntimeModelDiscoveryErrorSchema,+]);++export const HostRuntimeModelsFrameSchema = RuntimeModelDiscoveryRequestSchema.extend({+ type: z.literal("runtime_models"),+ result: z.discriminatedUnion("status", [+ z.strictObject({ status: z.literal("complete"), runtimeReport: CommunityMachineRuntimeListSchema }),+ RuntimeModelDiscoveryErrorSchema,+ ]),+});+const CommunityRunningAgentListSchema = z.array(z.string()).transform((list) => {const seen = new Set<string>();const out: string[] = [];diff --git a/src/shared/test/community-ws-bundle.contract.test.ts b/src/shared/test/community-ws-bundle.contract.test.tsindex e4efedecc..4115e322e 100644--- a/src/shared/test/community-ws-bundle.contract.test.ts+++ b/src/shared/test/community-ws-bundle.contract.test.ts@@ -145,7 +145,7 @@ describe("community WS batch transport contract", () => {expect(isCommunityDeliveryDigest("a".repeat(63))).toBe(false)})- it("round-trips one strict outer frame without entering the 46-event union", async () => {+ it("round-trips one strict outer frame without entering the 47-event union", async () => {const operationId = await deriveCommunityDeliveryOperationId("message-1")const prepared = await prepareCommunityDeliveryEvents(children)expect(prepared.ok).toBe(true)@@ -173,7 +173,7 @@ describe("community WS batch transport contract", () => {})expect(isCommunityBrowserEventBatchCandidate(encoded.batch)).toBe(true)expect(Object.values(WS_EVENTS)).not.toContain(COMMUNITY_BROWSER_EVENT_BATCH_TYPE)- expect(Object.values(WS_EVENTS)).toHaveLength(46)+ expect(Object.values(WS_EVENTS)).toHaveLength(47)})it("rejects invalid count, child, operation metadata, digest mismatch, and strict outer keys", async () => {diff --git a/src/shared/test/community-ws-events.contract.test.ts b/src/shared/test/community-ws-events.contract.test.tsindex d74fee50f..3b38cdd1f 100644--- a/src/shared/test/community-ws-events.contract.test.ts+++ b/src/shared/test/community-ws-events.contract.test.ts@@ -65,13 +65,13 @@ describe("Community browser event runtime contract", () => {const fixtures = Object.values(communityWsEventFixtures)const names = Object.values(WS_EVENTS).sort()- it("locks the exact 46-event inventory", () => {- expect(names).toHaveLength(46)+ it("locks the exact 47-event inventory", () => {+ expect(names).toHaveLength(47)expect(Object.keys(communityWsEventFixtures).sort()).toEqual(names)expect(Object.keys(requiredFixturePaths).sort()).toEqual(names)})- it("decodes and canonically encodes all 46 current event fixtures", () => {+ it("decodes and canonically encodes all 47 current event fixtures", () => {for (const fixture of fixtures) {expect(decodeCommunityBrowserEvent(fixture)).toEqual({ ok: true, event: fixture })const encoded = encodeCommunityBrowserEvent(fixture)diff --git a/src/shared/test/community-ws-events.fixtures.ts b/src/shared/test/community-ws-events.fixtures.tsindex dbbd681e7..a2afea1e0 100644--- a/src/shared/test/community-ws-events.fixtures.ts+++ b/src/shared/test/community-ws-events.fixtures.ts@@ -281,6 +281,7 @@ export const communityWsEventFixtures = {lastSeenAt: "2026-01-01T00:00:00.000Z",},"community:machine.updated": { type: "community:machine.updated", machine },+ "community:runtime.models": { type: "community:runtime.models", machineId: "machine-1", requestId: "request-1", runtimeId: "codex", result: { status: "complete", catalog: null } },"community:machine.removed": { type: "community:machine.removed", machineId: "machine-1" },"community:bot.audit_event": {type: "community:bot.audit_event",@@ -339,6 +340,7 @@ export const requiredFixturePaths = {"community:machine.created": ["machine"],"community:machine.status": ["lastSeenAt"],"community:machine.updated": ["machine"],+ "community:runtime.models": ["requestId"],"community:machine.removed": ["machineId"],"community:bot.audit_event": ["payload"],} satisfies Record<CommunityWsEvent["type"], readonly [string, ...string[]]>diff --git a/src/shared/test/community-ws-events.test.ts b/src/shared/test/community-ws-events.test.tsindex 309a04a13..7be4b94c5 100644--- a/src/shared/test/community-ws-events.test.ts+++ b/src/shared/test/community-ws-events.test.ts@@ -64,7 +64,7 @@ describe("CommunityMessageEdited address contract", () => {describe("isCommunityEvent", () => {it("accepts every exact event declared by WS_EVENTS", () => {- expect(Object.values(WS_EVENTS)).toHaveLength(46);+ expect(Object.values(WS_EVENTS)).toHaveLength(47);for (const type of Object.values(WS_EVENTS)) {expect(isCommunityEvent({ type })).toBe(true);}diff --git a/src/shared/test/community/bot-reasoning-effort.test.ts b/src/shared/test/community/bot-reasoning-effort.test.tsindex ab617e49d..58245c102 100644--- a/src/shared/test/community/bot-reasoning-effort.test.ts+++ b/src/shared/test/community/bot-reasoning-effort.test.ts@@ -41,6 +41,13 @@ describe("resolveReasoningEffort", () => {expect(resolveReasoningEffort(future, "future", "new_level").canonicalEffort).toBe("new_level");});+ it("keeps empty native metadata equivalent to the existing unreported-effort boundary", () => {+ const catalog = { reasoning: { updateMode: "unsupported" as const, models: [{ id: "native-model", supportedReasoningEfforts: [] }] } };+ const before = resolveReasoningEffort({}, "native-model", "high");+ expect(resolveReasoningEffort(catalog, "native-model", "high")).toEqual(before);+ expect(before).toMatchObject({ supported: false, canonicalEffort: null });+ });+it("falls an incompatible or unreported explicit effort back to Default", () => {expect(resolveReasoningEffort(runtime, "model-b", "xhigh")).toMatchObject({canonicalEffort: null,diff --git a/src/shared/test/http-json.test.ts b/src/shared/test/http-json.test.tsnew file mode 100644index 000000000..deb9cfd17--- /dev/null+++ b/src/shared/test/http-json.test.ts@@ -0,0 +1,66 @@+import { describe, expect, it } from "vitest"+import { readBoundedJsonRequest } from "../src/http-json"++const encoder = new TextEncoder()+const url = "http://localhost/bounded-json"+function streaming(chunks: Uint8Array[], cancel?: () => void) {+ const body = new ReadableStream<Uint8Array>({+ start(controller) { for (const chunk of chunks) controller.enqueue(chunk) },+ cancel,+ })+ return new Request(url, { method: "POST", body, duplex: "half" } as RequestInit)+}++describe("bounded HTTP JSON", () => {+ it("decodes UTF-8 split across chunks and reports bytes rather than characters", async () => {+ const bytes = encoder.encode(JSON.stringify({ text: "你好🌍" }))+ const body = new ReadableStream<Uint8Array>({ start(controller) {+ controller.enqueue(bytes.slice(0, 10))+ controller.enqueue(bytes.slice(10))+ controller.close()+ } })+ const request = new Request(url, { method: "POST", body, duplex: "half" } as RequestInit)+ expect(await readBoundedJsonRequest(request, bytes.length)).toEqual({ ok: true, value: { text: "你好🌍" }, byteCount: bytes.length })+ })++ it("rejects an oversized declared body before consuming it", async () => {+ const request = new Request(url, { method: "POST", headers: { "content-length": "1000" }, body: "{}" })+ expect(await readBoundedJsonRequest(request, 8)).toEqual({ ok: false, reason: "oversized", byteCount: 1000 })+ expect(request.bodyUsed).toBe(false)+ })++ it.each(["invalid", "-1", "1.5", "9007199254740992"])("bounds actual bytes when declared length is %s", async (length) => {+ const request = new Request(url, { method: "POST", headers: { "content-length": length }, body: "{}" })+ expect(await readBoundedJsonRequest(request, 2)).toEqual({ ok: true, value: {}, byteCount: 2 })+ })++ it.each([false, true])("cancels an oversized stream even if cancellation fails: %s", async (rejectCancellation) => {+ let cancelled = false+ const request = streaming([encoder.encode("{\"x\":"), encoder.encode("123456789}")], () => {+ cancelled = true+ if (rejectCancellation) throw new Error("cancel failed")+ })+ expect(await readBoundedJsonRequest(request, 8)).toEqual({ ok: false, reason: "oversized", byteCount: 15 })+ expect(cancelled).toBe(true)+ })++ it("contains a body stream failure", async () => {+ const body = new ReadableStream<Uint8Array>({ start(controller) { controller.error(new Error("read failed")) } })+ const request = new Request(url, { method: "POST", body, duplex: "half" } as RequestInit)+ expect(await readBoundedJsonRequest(request, 8)).toEqual({ ok: false, reason: "invalid-json", byteCount: 0 })+ })++ it("rejects invalid UTF-8 rather than replacing it before parsing", async () => {+ const request = streaming([new Uint8Array([0xff, 0xff])])+ expect(await readBoundedJsonRequest(request, 1)).toEqual({ ok: false, reason: "oversized", byteCount: 2 })+ const body = new ReadableStream<Uint8Array>({ start(controller) { controller.enqueue(new Uint8Array([0xff])); controller.close() } })+ expect(await readBoundedJsonRequest(new Request(url, { method: "POST", body, duplex: "half" } as RequestInit), 8)).toEqual({ ok: false, reason: "invalid-json", byteCount: 1 })+ })++ it("rejects absent, empty and malformed JSON bodies", async () => {+ for (const body of [undefined, "", "{"]) {+ const request = new Request(url, { method: "POST", ...(body === undefined ? {} : { body }) })+ expect(await readBoundedJsonRequest(request, 8)).toEqual({ ok: false, reason: "invalid-json", byteCount: body?.length ?? 0 })+ }+ })+})diff --git a/src/shared/test/queries/machine-session-epoch.integration.test.ts b/src/shared/test/queries/machine-session-epoch.integration.test.tsindex 491d0c99e..c9434ab19 100644--- a/src/shared/test/queries/machine-session-epoch.integration.test.ts+++ b/src/shared/test/queries/machine-session-epoch.integration.test.ts@@ -123,6 +123,19 @@ describe("machine session epoch SQL transaction", () => {});}+ it("preserves machine identity metadata on a catalog-only ready update", async () => {+ sqlite.prepare("UPDATE community_machine SET display_name = ? WHERE id = ?").run("My laptop", "cm_machine");+ const availableRuntimes = [{ id: "codex", reasoning: { updateMode: "unsupported" as const, models: [{ id: "native-model", supportedReasoningEfforts: [] }] } }];+ const result = await transitionMachineSessionEpoch(db as any, {+ type: "ready", epoch: { userId: "u_1", machineId: "cm_machine", credentialHash: OLD_HASH }, metadata: { availableRuntimes },+ });+ expect(result.type).toBe("transitioned");+ if (result.type !== "transitioned") throw new Error("epoch not accepted");+ const stored = sqlite.prepare("SELECT display_name AS displayName, hostname, platform, arch, os_release AS osRelease, daemon_version AS daemonVersion, available_runtimes AS availableRuntimes FROM community_machine WHERE id = ?").get("cm_machine") as Record<string, string>;+ expect(stored).toMatchObject({ displayName: "My laptop", hostname: "old-host", platform: "darwin", arch: "arm64", osRelease: "23", daemonVersion: "0.1.0" });+ expect(JSON.parse(stored.availableRuntimes!)).toEqual(availableRuntimes);+ });+it("commits credential, runner, and offline projection together and fences the old epoch", async () => {const result = await rotate();const newHash = await hashCredential(result.credential);diff --git a/src/web/src/app/api/community/bots/[id]/route.test.ts b/src/web/src/app/api/community/bots/[id]/route.test.tsindex c2b05ab1f..483fb18e8 100644--- a/src/web/src/app/api/community/bots/[id]/route.test.ts+++ b/src/web/src/app/api/community/bots/[id]/route.test.ts@@ -200,6 +200,19 @@ describe("PATCH /api/community/bots/[id]", () => {expect(mockPushAgentProviderSwitchToMachine).not.toHaveBeenCalled()})+ it("preserves a saved AGY effort on profile-only edits after catalog discovery", async () => {+ mockGetBotOwnedBy.mockResolvedValue({ id: "b1", name: "Old", description: "old", ownerUserId: "u1", machineId: "mac1", runtime: "agy", modelName: "gemini-3.8-flash-high", reasoningEffort: "high", runtimeConfigRevision: 3 })+ mockGetMachineForOwner.mockResolvedValue({ id: "mac1", availableRuntimes: [{ id: "agy", reasoning: { updateMode: "unsupported", models: [{ id: "gemini-3.8-flash-high", supportedReasoningEfforts: [] }] } }] })+ const response = await PATCH(patchReq({ description: "Updated" }), ctx)+ expect(response.status).toBe(200)+ expect(await response.json()).toMatchObject({ bot: { reasoningEffort: "high", modelName: "gemini-3.8-flash-high", runtimeConfigRevision: 3 } })+ expect(mockUpdateBotRuntimeConfig).not.toHaveBeenCalled()+ expect(mockPushAgentModelSwitchToMachine).not.toHaveBeenCalled()+ expect(mockPushAgentRuntimeConfigUpdateToMachine).not.toHaveBeenCalled()+ expect(mockPushBotEventToMachine).toHaveBeenCalledWith(expect.anything(), "mac1", expect.objectContaining({ type: "bot:updated" }))+ expect(mockPushBotEventToMachine.mock.calls[0]?.[2]).not.toHaveProperty("config")+ })+it("preserves a named OpenCode model on a profile-only edit without restarting", async () => {mockGetBotOwnedBy.mockResolvedValue({ id: "b1", name: "Old", runtime: "opencode", modelName: "provider/custom" })const res = await PATCH(patchReq({ description: "Updated" }), ctx)diff --git a/src/web/src/app/api/community/machines/[id]/discover-models/route.test.ts b/src/web/src/app/api/community/machines/[id]/discover-models/route.test.tsnew file mode 100644index 000000000..47cd295cf--- /dev/null+++ b/src/web/src/app/api/community/machines/[id]/discover-models/route.test.ts@@ -0,0 +1,56 @@+import { beforeEach, describe, expect, it, vi } from "vitest"+import { NextRequest } from "next/server"+const mocks = vi.hoisted(() => ({ machine: vi.fn(), dispatch: vi.fn() }))+vi.mock("@/lib/db", () => ({ getDb: () => ({ db: true }) }))+vi.mock("@/lib/broadcast", () => ({ wsDoFetch: mocks.dispatch }))+vi.mock("@alook/shared", async () => {+ const actual = await vi.importActual<typeof import("@alook/shared")>("@alook/shared")+ return { ...actual, queries: { communityMachine: { getMachineByIdForUser: mocks.machine } } }+})+vi.mock("@/lib/middleware/auth", () => ({ withAuth: (handler: any) => (req: any) => handler(req, { env: { DB: {} }, userId: "owner", params: { id: "machine" } }) }))+import { POST } from "./route"+const payload = { runtimeId: "codex", requestId: "request" }+const request = (body: unknown = payload) => new NextRequest("http://localhost/api/community/machines/machine/discover-models", { method: "POST", body: JSON.stringify(body) })+describe("model discovery owner route", () => {+ beforeEach(() => {+ vi.clearAllMocks()+ mocks.machine.mockResolvedValue({ status: "online", availableRuntimes: [{ id: "codex" }] })+ mocks.dispatch.mockResolvedValue(Response.json({ sent: 1, unsupported: 0 }))+ })+ it("scopes lookup before dispatch and acknowledges the correlated request", async () => {+ const response = await POST(request())+ expect(mocks.machine).toHaveBeenCalledWith({ db: true }, "owner", "machine")+ expect(response.status).toBe(202)+ expect(await response.json()).toEqual({ dispatched: true, requestId: "request" })+ expect(mocks.dispatch.mock.calls[0]?.[1]).toBe("/community-machine/by-id/machine/discover-models")+ expect(JSON.parse(mocks.dispatch.mock.calls[0]?.[2].body)).toEqual(payload)+ })+ it("does not dispatch a missing or foreign-owner machine", async () => {+ mocks.machine.mockResolvedValue(null)+ expect((await POST(request())).status).toBe(404)+ expect(mocks.dispatch).not.toHaveBeenCalled()+ })+ it.each([null, {}, { ...payload, runtimeId: "missing" }, { ...payload, command: "arbitrary" }, { ...payload, requestId: "x".repeat(129) }])("rejects invalid payload %j", async (body) => {+ expect((await POST(request(body))).status).toBe(400)+ expect(mocks.dispatch).not.toHaveBeenCalled()+ })+ it("rejects offline machines before dispatch", async () => {+ mocks.machine.mockResolvedValue({ status: "offline" })+ expect((await POST(request())).status).toBe(409)+ expect(mocks.dispatch).not.toHaveBeenCalled()+ })+ it.each([[{ sent: 0, unsupported: 1 }, 409, "UPGRADE_REQUIRED"], [{ sent: 0, unsupported: 0 }, 409, "MACHINE_OFFLINE"], [{ sent: "1" }, 503, "model discovery unavailable"]])("handles dispatch receipt %j", async (receipt, status, error) => {+ mocks.dispatch.mockResolvedValue(Response.json(receipt))+ const response = await POST(request())+ expect(response.status).toBe(status)+ expect(await response.json()).toEqual({ error })+ })+ it("handles transport failure without reporting success", async () => {+ mocks.dispatch.mockRejectedValue(new Error("private transport data"))+ expect((await POST(request())).status).toBe(503)+ })+ it("bounds streamed bodies before parsing", async () => {+ expect((await POST(request({ ...payload, excess: "x".repeat(4096) }))).status).toBe(400)+ expect(mocks.dispatch).not.toHaveBeenCalled()+ })+})diff --git a/src/web/src/app/api/community/machines/[id]/discover-models/route.ts b/src/web/src/app/api/community/machines/[id]/discover-models/route.tsnew file mode 100644index 000000000..2a87bddb3--- /dev/null+++ b/src/web/src/app/api/community/machines/[id]/discover-models/route.ts@@ -0,0 +1,32 @@+import { queries, readBoundedJsonRequest, RuntimeModelDiscoveryRequestSchema } from "@alook/shared"+import { getDb } from "@/lib/db"+import { withAuth } from "@/lib/middleware/auth"+import { writeError, writeJSON } from "@/lib/middleware/helpers"+import { wsDoFetch } from "@/lib/broadcast"++export const POST = withAuth(async (req, ctx) => {+ const id = ctx.params?.id as string+ const machine = await queries.communityMachine.getMachineByIdForUser(getDb(ctx.env.DB), ctx.userId, id)+ if (!machine) return writeError("machine not found", 404)+ if (machine.status !== "online") return writeError("MACHINE_OFFLINE", 409)+ const input = await readBoundedJsonRequest(req, 4096)+ const payload = RuntimeModelDiscoveryRequestSchema.safeParse(input.ok ? input.value : null)+ if (!payload.success) return writeError("invalid request", 400)+ if (!machine.availableRuntimes.some((runtime) => runtime.id === payload.data.runtimeId)) {+ return writeError("runtime not found", 400)+ }+ try {+ const response = await wsDoFetch(ctx.env, `/community-machine/by-id/${encodeURIComponent(id)}/discover-models`, {+ method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(payload.data),+ })+ if (!response.ok) return writeError("model discovery unavailable", 503)+ const receipt = await response.json() as { sent?: unknown; unsupported?: unknown }+ if (typeof receipt.sent !== "number" || !Number.isSafeInteger(receipt.sent) || receipt.sent < 0) {+ return writeError("model discovery unavailable", 503)+ }+ if (receipt.sent > 0) return writeJSON({ dispatched: true, requestId: payload.data.requestId }, 202)+ return writeError(typeof receipt.unsupported === "number" && receipt.unsupported > 0 ? "UPGRADE_REQUIRED" : "MACHINE_OFFLINE", 409)+ } catch {+ return writeError("model discovery unavailable", 503)+ }+})diff --git a/src/web/src/components/community/bots/bot-runtime-fields.tsx b/src/web/src/components/community/bots/bot-runtime-fields.tsxindex cfd91c33b..ffb2efefe 100644--- a/src/web/src/components/community/bots/bot-runtime-fields.tsx+++ b/src/web/src/components/community/bots/bot-runtime-fields.tsx@@ -1,5 +1,7 @@"use client"+import type { ComponentProps } from "react"+import { useRuntimeModels } from "@/hooks/community/use-runtime-models"import { ProviderLogo } from "@/components/provider-logo"import { Label } from "@/components/ui/label"import { cn } from "@/lib/utils"@@ -22,6 +24,7 @@ export function BotRuntimeFields({runtime,model,daemonVersion,+ machineId,reasoningEffort = null,onRuntimeChange,onModelChange,@@ -39,6 +42,7 @@ export function BotRuntimeFields({runtime: stringmodel: string | nulldaemonVersion?: string+ machineId?: stringreasoningEffort?: ReasoningEffort | nullonRuntimeChange: (runtime: string) => voidonModelChange: (model: string | null) => void@@ -117,7 +121,11 @@ export function BotRuntimeFields({</div>{runtime ? (<div data-motion-target={modelMotionTarget} className={cn("flex flex-col gap-4", modelClassName)}>- <ModelField runtime={selectedRuntime} value={model} onChange={onModelChange} error={modelError} />+ {machineId ? (+ <MachineModelField key={`${machineId}:${runtime}`} machineId={machineId} runtime={selectedRuntime} value={model} onChange={onModelChange} error={modelError} />+ ) : (+ <ModelField runtime={selectedRuntime} value={model} onChange={onModelChange} error={modelError} />+ )}<ReasoningEffortFieldruntime={selectedRuntime}model={model}@@ -130,3 +138,8 @@ export function BotRuntimeFields({</>)}++function MachineModelField({ machineId, ...props }: ComponentProps<typeof ModelField> & { machineId: string }) {+ const discovery = useRuntimeModels(machineId, props.runtime?.id ?? "")+ return <ModelField {...props} discovery={discovery} />+}diff --git a/src/web/src/components/community/bots/create-bot-sheet.tsx b/src/web/src/components/community/bots/create-bot-sheet.tsxindex c0d5bc49f..d1f9b7926 100644--- a/src/web/src/components/community/bots/create-bot-sheet.tsx+++ b/src/web/src/components/community/bots/create-bot-sheet.tsx@@ -329,6 +329,7 @@ export function CreateBotSheet({{selectedMachine && (<div className="flex flex-col gap-2"><BotRuntimeFields+ machineId={selectedMachine.id}options={runtimeOptions}runtime={runtime}model={model}diff --git a/src/web/src/components/community/bots/edit-bot-sheet.tsx b/src/web/src/components/community/bots/edit-bot-sheet.tsxindex ea6a41294..d2775ced3 100644--- a/src/web/src/components/community/bots/edit-bot-sheet.tsx+++ b/src/web/src/components/community/bots/edit-bot-sheet.tsx@@ -230,6 +230,7 @@ const [avatarDraft, setAvatarDraft] = useAtom(useCreateAtom<AvatarDraft>(((): Av/>{bot && (<BotRuntimeFields+ machineId={selectedMachine?.id}options={runtimeOptions}runtime={runtime}model={model}diff --git a/src/web/src/components/community/bots/model-field-select.dom.test.tsx b/src/web/src/components/community/bots/model-field-select.dom.test.tsxindex 341bec43f..60344fb4b 100644--- a/src/web/src/components/community/bots/model-field-select.dom.test.tsx+++ b/src/web/src/components/community/bots/model-field-select.dom.test.tsx@@ -16,6 +16,37 @@ const runtime = {}describe("ModelField with the real Select", () => {+ it("notifies discovery only when the actual model popup opens", async () => {+ const onOpenChange = vi.fn()+ render(<ModelField runtime={runtime} value={null} onChange={vi.fn()}+ discovery={{ isPending: false, error: null, onOpenChange, retry: vi.fn() }} />)+ expect(onOpenChange).not.toHaveBeenCalled()+ await act(async () => { fireEvent.click(screen.getByTestId("bot-model-select")) })+ expect(onOpenChange).toHaveBeenCalledWith(true)+ })++ it("shows model discovery loading without clearing the stored selection or Default", async () => {+ const onChange = vi.fn()+ render(<ModelField runtime={runtime} value="gemini-3.1-pro-high" onChange={onChange}+ discovery={{ isPending: true, error: null, onOpenChange: vi.fn(), retry: vi.fn() }} />)+ await act(async () => { fireEvent.click(screen.getByTestId("bot-model-select")) })+ expect(screen.getByRole("status")).toHaveTextContent("Loading models…")+ expect(screen.getByTestId("bot-model-select")).toHaveTextContent("gemini-3.1-pro-high")+ expect(screen.getByRole("option", { name: "Default (antigravity's own default)" })).toBeInTheDocument()+ expect(onChange).not.toHaveBeenCalled()+ })++ it("retries a model discovery failure without selecting or submitting a model", async () => {+ const retry = vi.fn(), onChange = vi.fn()+ render(<ModelField runtime={runtime} value="gemini-3.1-pro-high" onChange={onChange}+ discovery={{ isPending: false, error: "Could not load models", onOpenChange: vi.fn(), retry }} />)+ await act(async () => { fireEvent.click(screen.getByTestId("bot-model-select")) })+ expect(screen.getByRole("alert")).toHaveTextContent("Could not load models")+ await act(async () => { fireEvent.click(screen.getByRole("button", { name: "Retry" })) })+ expect(retry).toHaveBeenCalledOnce()+ expect(onChange).not.toHaveBeenCalled()+ expect(screen.getByTestId("bot-model-select")).toHaveTextContent("gemini-3.1-pro-high")+ })it.each([true, false])("requires OpenCode selection with a catalog=%s and keeps empty Custom editable", async (catalog) => {const selectedRuntime = { ...runtime, id: "opencode", reasoning: catalog ? runtime.reasoning : undefined }function Controlled() {diff --git a/src/web/src/components/community/bots/model-field.tsx b/src/web/src/components/community/bots/model-field.tsxindex 85178e0ab..f804b74b9 100644--- a/src/web/src/components/community/bots/model-field.tsx+++ b/src/web/src/components/community/bots/model-field.tsx@@ -2,6 +2,7 @@import { useAtom, useCreateAtom } from "@tanstack/react-store";import { useEffect, useId, useMemo } from "react"+import { LoaderCircle } from "lucide-react"import {modelSelectState,modelNameFromSelect,@@ -12,6 +13,7 @@ import {import type { CommunityMachineRuntime } from "@alook/shared"import { Label } from "@/components/ui/label"import { Input } from "@/components/ui/input"+import { Button } from "@/components/ui/button"import {Select,SelectTrigger,@@ -36,12 +38,19 @@ export function ModelField({onChange,disabled,error,+ discovery,}: {runtime: Pick<CommunityMachineRuntime, "id" | "reasoning"> | nullvalue: string | nullonChange: (v: string | null) => voiddisabled?: booleanerror?: string+ discovery?: {+ isPending: boolean+ error: string | null+ onOpenChange: (open: boolean) => void+ retry: () => void+ }}) {const hintId = useId()const required = requiresExplicitModel(runtime?.id)@@ -115,6 +124,7 @@ export function ModelField({onChange(nextModel)}}onOpenChange={(open) => {+ discovery?.onOpenChange(open)if (!open) setFilterQuery("")}}disabled={disabled}@@ -125,11 +135,30 @@ export function ModelField({aria-required={required}aria-describedby={required || error ? hintId : undefined}aria-invalid={Boolean(error)}+ aria-busy={discovery?.isPending || undefined}className="w-full data-[size=default]:h-11 sm:data-[size=default]:h-8"><SelectValue placeholder={placeholder} /></SelectTrigger>- <BotSelectMenuContent className="overflow-y-hidden">+ <BotSelectMenuContent+ alignItemWithTrigger={false}+ className="flex flex-col overflow-y-hidden [&>[role=listbox]]:flex [&>[role=listbox]]:min-h-0 [&>[role=listbox]]:flex-col"+ >+ {discovery?.isPending && (+ <p role="status" className="flex shrink-0 items-center gap-2 px-2 py-2 text-xs text-muted-foreground">+ <LoaderCircle className="size-3.5 animate-spin motion-reduce:animate-none" aria-hidden />+ Loading models…+ </p>+ )}+ {discovery?.error && (+ <div className="flex shrink-0 items-center gap-2 px-2 py-2">+ <p role="alert" className="min-w-0 flex-1 text-xs text-destructive">{discovery.error}</p>+ <Button type="button" variant="ghost" size="sm" className="h-11 shrink-0 sm:h-8"+ onClick={(event) => { event.stopPropagation(); discovery.retry() }}>+ Retry+ </Button>+ </div>+ )}{modelIds.length === 0 ? (<>{!required && <BotSelectMenuItem value={MODEL_SELECT_DEFAULT}>{defaultLabel}</BotSelectMenuItem>}@@ -171,7 +200,7 @@ export function ModelField({</div><divdata-testid="bot-model-probe-results"- className="thin-scrollbar max-h-[min(18rem,50dvh)] overflow-y-auto"+ className="thin-scrollbar min-h-0 max-h-[min(18rem,50dvh)] overflow-y-auto">{filteredModels.map((model) => (<BotSelectMenuItem key={model.id} value={model.id}>diff --git a/src/web/src/components/community/bots/reasoning-effort-field.dom.test.ts b/src/web/src/components/community/bots/reasoning-effort-field.dom.test.tsindex 1c65ee2af..101a725a9 100644--- a/src/web/src/components/community/bots/reasoning-effort-field.dom.test.ts+++ b/src/web/src/components/community/bots/reasoning-effort-field.dom.test.ts@@ -121,7 +121,7 @@ describe("ReasoningEffortField", () => {expect(onChange).toHaveBeenCalledWith(null)})- it("clears an override when the reported model has no effort options", () => {+ it("preserves an override when the reported model has no effort metadata", () => {const { renderer, onChange } = renderField({runtime: { reasoning: { updateMode: "live_next_turn", models: [{ id: "claude-sonnet-4-6", supportedReasoningEfforts: [] },@@ -130,7 +130,9 @@ describe("ReasoningEffortField", () => {value: "high",})expect(renderer.container.querySelector("select")).toBeDisabled()- expect(onChange).toHaveBeenCalledWith(null)+ expect(JSON.parse(renderer.container.querySelector("select")!.dataset.items!))+ .toContainEqual({ value: "high", label: "High" })+ expect(onChange).not.toHaveBeenCalled()})it("preserves an override for a custom model absent from the catalog", () => {@@ -161,4 +163,20 @@ describe("ReasoningEffortField", () => {act(() => selectOnChange?.("__default__"))expect(onChange).toHaveBeenLastCalledWith(null)})++ it("preserves stored effort when an on-demand catalog arrives without effort metadata", () => {+ const { renderer, onChange } = renderField({ runtime: { reasoning: undefined }, model: "native-id", value: "high" })+ expect(onChange).not.toHaveBeenCalled()+ renderer.rerender(React.createElement(ReasoningEffortField, {+ runtime: { reasoning: { updateMode: "context_preserving_restart", models: [+ { id: "native-id", supportedReasoningEfforts: [] },+ ] } },+ model: "native-id", daemonVersion: "0.1.52", value: "high", onChange,+ }))+ expect(renderer.container.querySelector("select")).toBeDisabled()+ expect(JSON.parse(renderer.container.querySelector("select")!.dataset.items!))+ .toContainEqual({ value: "high", label: "High" })+ expect(onChange).not.toHaveBeenCalled()+ })+})diff --git a/src/web/src/components/community/bots/reasoning-effort-field.tsx b/src/web/src/components/community/bots/reasoning-effort-field.tsxindex 98ba9ef5c..db25ebca5 100644--- a/src/web/src/components/community/bots/reasoning-effort-field.tsx+++ b/src/web/src/components/community/bots/reasoning-effort-field.tsx@@ -46,10 +46,10 @@ export function ReasoningEffortField({const hasModelEvidence = runtime?.reasoning?.models.some((model) => model.id === resolution.modelId) ?? falseuseEffect(() => {- if (hasModelEvidence && !resolution.supported && value !== null) {+ if (hasModelEvidence && resolution.options.length > 0 && !resolution.supported && value !== null) {onChange(null)}- }, [hasModelEvidence, onChange, resolution.supported, value])+ }, [hasModelEvidence, onChange, resolution.options.length, resolution.supported, value])const defaultLabel = "Default"const options = value && !resolution.options.some((option) => option.value === value)diff --git a/src/web/src/hooks/community/community-ws/presence-machine-events.dom.test.ts b/src/web/src/hooks/community/community-ws/presence-machine-events.dom.test.tsindex a8e6ba839..f42c95445 100644--- a/src/web/src/hooks/community/community-ws/presence-machine-events.dom.test.ts+++ b/src/web/src/hooks/community/community-ws/presence-machine-events.dom.test.ts@@ -139,6 +139,34 @@ describe("useCommunityWs — machines", () => {}const readCache = () => capturedQueryClient.getQueryData<MachinesResponse>(communityKeys.machines())+ it("runtime catalog results preserve unrelated machines and legacy or other runtimes", async () => {+ await mountHook()+ const original = {+ ...machine("m1"), availableRuntimes: ["legacy", { id: "agy", status: "healthy" }, { id: "codex", status: "healthy" }],+ }+ const other = machine("m2")+ const originalCapacity = { ...capacity, ownedCount: 2 }+ capturedQueryClient.setQueryData(communityKeys.machines(), { machines: [original, other], machineCapacity: originalCapacity })+ const key = communityKeys.runtimeModels("m1", "codex")+ capturedQueryClient.setQueryData(key, { requestId: "current", status: "pending" })+ const catalog = { updateMode: "live_next_turn", models: [{ id: "native-model", supportedReasoningEfforts: [] }] }+ capturedOnMessage!({ type: "community:runtime.models", machineId: "m1", runtimeId: "codex", requestId: "current", result: { status: "complete", catalog } })+ expect(capturedQueryClient.getQueryData(key)).toEqual({ requestId: "current", status: "complete", catalog })+ expect(readCache()).toEqual({+ machines: [{ ...original, availableRuntimes: ["legacy", { id: "agy", status: "healthy" }, { id: "codex", status: "healthy", reasoning: catalog }] }, other],+ machineCapacity: originalCapacity,+ })+ })++ it("runtime catalog results complete the request without inventing a missing machine snapshot", async () => {+ await mountHook()+ const key = communityKeys.runtimeModels("m1", "codex")+ capturedQueryClient.setQueryData(key, { requestId: "current", status: "pending" })+ capturedOnMessage!({ type: "community:runtime.models", machineId: "m1", runtimeId: "codex", requestId: "current", result: { status: "complete", catalog: null } })+ expect(capturedQueryClient.getQueryData(key)).toEqual({ requestId: "current", status: "complete", catalog: null })+ expect(readCache()).toBeUndefined()+ })+it.each(["created", "updated"] as const)("machine.%s upserts without double-counting and preserves the allowance", async (kind) => {await mountHook()const original = machine("existing")diff --git a/src/web/src/hooks/community/community-ws/presence-machine-events.ts b/src/web/src/hooks/community/community-ws/presence-machine-events.tsindex 660fbba7c..46c1f2761 100644--- a/src/web/src/hooks/community/community-ws/presence-machine-events.ts+++ b/src/web/src/hooks/community/community-ws/presence-machine-events.ts@@ -9,11 +9,13 @@ import type {CommunityMachineSummary,CommunityMachineUpdated,CommunityPresenceUpdate,+ CommunityWsEvent,CommunityStatusUpdate,} from "@alook/shared"import { communityKeys } from "@/lib/query-keys"+import type { RuntimeModelsState } from "@/hooks/community/use-runtime-models"import type { MachinesResponse } from "@/hooks/community/use-machines"import type { PresenceMachineEventContext } from "@/hooks/community/community-ws/handler-context"@@ -102,3 +104,22 @@ export function handleMachineRemoved(prev ? replaceMachines(prev, prev.machines.filter((m) => m.id !== event.machineId)) : prev,)}++export function handleRuntimeModels(event: Extract<CommunityWsEvent, { type: "community:runtime.models" }>, { queryClient }: PresenceMachineEventContext) {+ const key = communityKeys.runtimeModels(event.machineId, event.runtimeId)+ const pending = queryClient.getQueryData<RuntimeModelsState>(key)+ if (pending?.status !== "pending" || pending.requestId !== event.requestId) return+ queryClient.setQueryData<RuntimeModelsState>(key, { requestId: event.requestId, ...event.result })+ if (event.result.status !== "complete") return+ const catalog = event.result.catalog+ queryClient.setQueryData<MachinesResponse>(communityKeys.machines(), (previous) => previous+ ? replaceMachines(previous, previous.machines.map((machine) => machine.id === event.machineId+ ? { ...machine, availableRuntimes: machine.availableRuntimes.map((runtime) => {+ if (typeof runtime === "string" || runtime.id !== event.runtimeId) return runtime+ const { reasoning: _previousCatalog, ...rest } = runtime+ return catalog ? { ...rest, reasoning: catalog } : rest+ }) }+ : machine))+ : previous,+ )+}diff --git a/src/web/src/hooks/community/community-ws/registry.test.ts b/src/web/src/hooks/community/community-ws/registry.test.tsindex d46016836..b0238389b 100644--- a/src/web/src/hooks/community/community-ws/registry.test.ts+++ b/src/web/src/hooks/community/community-ws/registry.test.ts@@ -62,6 +62,7 @@ vi.mock("./presence-machine-events", () => ({handleMachineStatus: handlers.handleMachineStatus,handleMachineUpdated: handlers.handleMachineUpdated,handlePresenceUpdate: handlers.handlePresenceUpdate,+ handleRuntimeModels: handlers.handleRuntimeModels,handleStatusUpdate: handlers.handleStatusUpdate,}))vi.mock("./identity-events", () => ({@@ -84,10 +85,10 @@ function dispatchContext(queryClient = new QueryClient()): CommunityWsDispatchCo}describe("community WebSocket registry", () => {- it("has exactly one entry for each of the 45 runtime event types", () => {+ it("has exactly one entry for each runtime event type", () => {const eventTypes = Object.values(WS_EVENTS).sort()const registryTypes = Object.keys(communityWsRegistry).sort()- expect(eventTypes).toHaveLength(46)+ expect(eventTypes).toHaveLength(47)expect(registryTypes).toEqual(eventTypes)})@@ -135,6 +136,7 @@ describe("community WebSocket registry", () => {["community:presence.update", "handlePresenceUpdate"],["community:profile.update", "handleProfileUpdate"],["community:machine.created", "handleMachineCreated"],+ ["community:runtime.models", "handleRuntimeModels"],["community:bot.audit_event", "handleBotAuditEvent"],] as const)("dispatches %s through its existing handler group", (type, handlerName) => {const context = dispatchContext()diff --git a/src/web/src/hooks/community/community-ws/registry.ts b/src/web/src/hooks/community/community-ws/registry.tsindex 5b0da5d5e..9a0888dd5 100644--- a/src/web/src/hooks/community/community-ws/registry.ts+++ b/src/web/src/hooks/community/community-ws/registry.ts@@ -48,6 +48,7 @@ import {handleMachineStatus,handleMachineUpdated,handlePresenceUpdate,+ handleRuntimeModels,handleStatusUpdate,} from "@/hooks/community/community-ws/presence-machine-events"import {@@ -111,6 +112,7 @@ export const communityWsRegistry = {"community:machine.status": { handler: handleMachineStatus, reconnectPolicies: ["machines"] },"community:machine.updated": { handler: handleMachineUpdated, reconnectPolicies: ["machines"] },"community:machine.removed": { handler: handleMachineRemoved, reconnectPolicies: ["machines"] },+ "community:runtime.models": { handler: handleRuntimeModels, reconnectPolicies: ["machines"] },"community:bot.audit_event": { handler: handleBotAuditEvent, reconnectPolicies: ["bot-audits"] },} satisfies CommunityWsRegistrydiff --git a/src/web/src/hooks/community/use-runtime-models.dom.test.ts b/src/web/src/hooks/community/use-runtime-models.dom.test.tsnew file mode 100644index 000000000..04569f5d5--- /dev/null+++ b/src/web/src/hooks/community/use-runtime-models.dom.test.ts@@ -0,0 +1,177 @@+import { createElement, type PropsWithChildren } from "react"+import { QueryClient } from "@tanstack/react-query"+import { beforeEach, describe, expect, it, vi } from "vitest"+import { CommunityTestProvider } from "@/test/community-owner-fixture"+import { act, renderHook, waitFor } from "@/test/react-dom-harness"+import { communityKeys } from "@/lib/query-keys"+import { getCommunityRuntime } from "@/stores/community/runtime"+import { handleRuntimeModels } from "./community-ws/presence-machine-events"+import { useRuntimeModels, type RuntimeModelsState } from "./use-runtime-models"+import type { MachinesResponse } from "./use-machines"++const apiFetch = vi.fn()+vi.mock("@/lib/api/client", () => ({ apiFetch: (...args: unknown[]) => apiFetch(...args) }))+beforeEach(() => { apiFetch.mockReset(); apiFetch.mockResolvedValue({ dispatched: true }) })++function mount() {+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })+ const wrapper = ({ children }: PropsWithChildren) => createElement(CommunityTestProvider, { client: queryClient }, children)+ const hook = renderHook(({ machine, runtime }) => useRuntimeModels(machine, runtime), {+ wrapper, initialProps: { machine: "m1", runtime: "codex" },+ })+ const request = (machine = "m1", runtime = "codex") => queryClient.getQueryData<RuntimeModelsState>(communityKeys.runtimeModels(machine, runtime))!+ const complete = (requestId: string, machineId = "m1", runtimeId = "codex") => act(() => handleRuntimeModels({+ type: "community:runtime.models", requestId, machineId, runtimeId, result: { status: "complete", catalog: null },+ }, { queryClient }))+ return { ...hook, queryClient, request, complete }+}++describe("on-demand runtime models", () => {+ it("does not prefetch on mount or runtime change, and sends the selected scope only on open", async () => {+ const h = mount()+ h.rerender({ machine: "m2", runtime: "agy" })+ expect(apiFetch).not.toHaveBeenCalled()+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(apiFetch).toHaveBeenCalledTimes(1))+ expect(apiFetch.mock.calls[0][0]).toBe("/api/community/machines/m2/discover-models")+ expect(JSON.parse(apiFetch.mock.calls[0][1].body)).toEqual({ requestId: h.request("m2", "agy").requestId, runtimeId: "agy" })+ expect(h.result.current.isPending).toBe(true)+ act(() => h.result.current.onOpenChange(true))+ expect(apiFetch).toHaveBeenCalledTimes(1)+ })++ it("accepts only the matching pending WS result and preserves machine metadata", async () => {+ const h = mount()+ const machine = { id: "m1", availableRuntimes: [{ id: "codex", status: "healthy", reasoning: { updateMode: "unsupported", models: [] } }], quota: [{ keep: true }] }+ h.queryClient.setQueryData(communityKeys.machines(), { machines: [machine], extra: "keep" })+ act(() => h.result.current.onOpenChange(true))+ h.complete("older")+ h.complete(h.request().requestId, "other")+ expect(h.request().status).toBe("pending")+ h.complete(h.request().requestId)+ await waitFor(() => expect(h.result.current.isPending).toBe(false))+ const cached = h.queryClient.getQueryData<MachinesResponse>(communityKeys.machines())!+ expect(cached.machines[0].availableRuntimes).toEqual([{ id: "codex", status: "healthy" }])+ expect(cached.machines[0].quota).toEqual([{ keep: true }])+ expect(cached).toHaveProperty("extra", "keep")+ })++ it("retires pending requests on close and machine/runtime change", async () => {+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ const first = h.request().requestId+ act(() => h.result.current.onOpenChange(false))+ h.complete(first)+ expect(h.request().status).toBe("cancelled")+ act(() => h.result.current.onOpenChange(true))+ const second = h.request().requestId+ expect(second).not.toBe(first)+ h.rerender({ machine: "m2", runtime: "agy" })+ h.complete(second)+ expect(h.request().status).toBe("cancelled")+ expect(h.queryClient.getQueryData(communityKeys.runtimeModels("m2", "agy"))).toBeUndefined()+ })++ it("shows a readable offline failure and Retry starts a fresh request", async () => {+ apiFetch.mockRejectedValueOnce(new Error("MACHINE_OFFLINE"))+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ const first = h.request().requestId+ await waitFor(() => expect(h.result.current.error).toBe("This machine is offline."))+ act(() => h.result.current.retry())+ expect(h.request().requestId).not.toBe(first)+ await waitFor(() => expect(apiFetch).toHaveBeenCalledTimes(2))+ expect(h.result.current.isPending).toBe(true)+ })++ it.each([+ { scenario: "generic fallback", error: "invalid error response", expected: "Could not load models." },+ { scenario: "daemon upgrade instruction", error: new Error("UPGRADE_REQUIRED"), expected: "Update this machine’s daemon to load models." },+ { scenario: "native error message", error: new Error("Native model query failed."), expected: "Native model query failed." },+ ])("shows the $scenario after request failure", async ({ error, expected }) => {+ apiFetch.mockRejectedValueOnce(error)+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(h.result.current.error).toBe(expected))+ expect(h.result.current.isPending).toBe(false)+ expect(apiFetch).toHaveBeenCalledTimes(1)+ })++ it("a late failed request does not recreate a removed cache or affect the new machine", async () => {+ let rejectRequest!: (error: unknown) => void+ apiFetch.mockImplementationOnce(() => new Promise((_, reject) => { rejectRequest = reject }))+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(apiFetch).toHaveBeenCalledTimes(1))+ h.rerender({ machine: "m2", runtime: "agy" })+ act(() => h.queryClient.removeQueries({ queryKey: communityKeys.runtimeModels("m1", "codex"), exact: true }))+ await act(async () => { rejectRequest(new Error("Late native failure.")) })+ expect(h.queryClient.getQueryData(communityKeys.runtimeModels("m1", "codex"))).toBeUndefined()+ expect(h.queryClient.getQueryData(communityKeys.runtimeModels("m2", "agy"))).toBeUndefined()+ expect(h.result.current.error).toBeNull()+ expect(h.result.current.isPending).toBe(false)+ expect(apiFetch).toHaveBeenCalledTimes(1)+ })++ it("opening while disconnected ends loading without dispatching a request", async () => {+ const h = mount()+ act(() => getCommunityRuntime(h.queryClient).ws.actions.setConnectionStatus("failed"))+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(h.result.current.error).toBe("Reconnect to load models."))+ expect(h.result.current.isPending).toBe(false)+ expect(apiFetch).not.toHaveBeenCalled()+ })++ it("a late aborted request does not replace the cancelled state with an error", async () => {+ let rejectRequest!: (error: unknown) => void+ apiFetch.mockImplementationOnce(() => new Promise((_, reject) => { rejectRequest = reject }))+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(apiFetch).toHaveBeenCalledTimes(1))+ const id = h.request().requestId+ act(() => h.result.current.onOpenChange(false))+ await act(async () => { rejectRequest(new DOMException("Request cancelled", "AbortError")) })+ await waitFor(() => expect(h.result.current.isPending).toBe(false))+ expect(h.request()).toEqual({ requestId: id, status: "cancelled" })+ expect(h.result.current.error).toBeNull()+ })++ it("ends loading on disconnect and ignores the late native result", async () => {+ const h = mount()+ act(() => h.result.current.onOpenChange(true))+ const id = h.request().requestId+ act(() => getCommunityRuntime(h.queryClient).ws.actions.setConnectionStatus("reconnecting"))+ await waitFor(() => expect(h.result.current.error).toBe("Connection lost. Retry to load models."))+ h.complete(id)+ expect(h.request().status).toBe("error")+ })++ it("ends loading at 45 seconds and ignores a result after timeout", async () => {+ const h = mount()+ const timeout = vi.spyOn(globalThis, "setTimeout")+ act(() => h.result.current.onOpenChange(true))+ await waitFor(() => expect(h.result.current.isPending).toBe(true))+ const id = h.request().requestId+ const callback = timeout.mock.calls.find((call) => call[1] === 45_000)?.[0]+ expect(callback).toBeTypeOf("function")+ act(() => { if (typeof callback === "function") callback() })+ await waitFor(() => expect(h.result.current.error).toBe("Model discovery timed out. Retry to load models."))+ h.complete(id)+ expect(h.request().status).toBe("error")+ timeout.mockRestore()+ })++ it("applies the native catalog and preserves it when a later discovery fails", async () => {+ const h = mount()+ h.queryClient.setQueryData(communityKeys.machines(), { machines: [{ id: "m1", availableRuntimes: [{ id: "codex" }] }] })+ act(() => h.result.current.onOpenChange(true))+ const catalog = { updateMode: "live_next_turn" as const, models: [{ id: "native-model", supportedReasoningEfforts: [] }] }+ act(() => handleRuntimeModels({ type: "community:runtime.models", machineId: "m1", runtimeId: "codex", requestId: h.request().requestId, result: { status: "complete", catalog } }, { queryClient: h.queryClient }))+ expect(h.queryClient.getQueryData<MachinesResponse>(communityKeys.machines())!.machines[0].availableRuntimes[0].reasoning).toEqual(catalog)+ act(() => h.result.current.retry())+ act(() => handleRuntimeModels({ type: "community:runtime.models", machineId: "m1", runtimeId: "codex", requestId: h.request().requestId, result: { status: "error", code: "model_discovery_timeout", message: "Model query timed out." } }, { queryClient: h.queryClient }))+ await waitFor(() => expect(h.result.current.error).toBe("Model query timed out."))+ expect(h.queryClient.getQueryData<MachinesResponse>(communityKeys.machines())!.machines[0].availableRuntimes[0].reasoning).toEqual(catalog)+ })++})diff --git a/src/web/src/hooks/community/use-runtime-models.ts b/src/web/src/hooks/community/use-runtime-models.tsnew file mode 100644index 000000000..ac11bf8dc--- /dev/null+++ b/src/web/src/hooks/community/use-runtime-models.ts@@ -0,0 +1,78 @@+"use client"++import { useCallback, useEffect, useMemo, useRef } from "react"+import { skipToken, useQuery, useQueryClient } from "@tanstack/react-query"+import type { RuntimeModelDiscoveryResult } from "@alook/shared"+import { communityKeys } from "@/lib/query-keys"+import { isAbortError } from "@/lib/errors"+import { useCommunityWsStore } from "@/stores/community/ws"+import { useCommunityMutationOrigin } from "./community-origin"++export type RuntimeModelsState = { requestId: string } & (+ | { status: "pending" | "cancelled" }+ | RuntimeModelDiscoveryResult+)++export function useRuntimeModels(machineId: string, runtimeId: string) {+ const queryClient = useQueryClient()+ const origin = useCommunityMutationOrigin()+ const ownedRequest = useRef<string | null>(null)+ const connectionStatus = useCommunityWsStore((state) => state.connectionStatus)+ const queryKey = useMemo(() => communityKeys.runtimeModels(machineId, runtimeId), [machineId, runtimeId])+ const { data } = useQuery<RuntimeModelsState>({ queryKey, queryFn: skipToken, gcTime: 60_000 })++ const finishError = useCallback((requestId: string, message: string) => {+ queryClient.setQueryData<RuntimeModelsState>(queryKey, (current) =>+ current?.requestId === requestId && current.status === "pending"+ ? { requestId, status: "error", code: "DISCOVERY_FAILED", message }+ : current,+ )+ }, [queryClient, queryKey])++ const cancel = useCallback(() => {+ queryClient.setQueryData<RuntimeModelsState>(queryKey, (current) =>+ current?.status === "pending" && current.requestId === ownedRequest.current+ ? { requestId: current.requestId, status: "cancelled" } : current,+ )+ ownedRequest.current = null+ }, [queryClient, queryKey])++ function discover() {+ if (queryClient.getQueryData<RuntimeModelsState>(queryKey)?.status === "pending") return+ const requestId = crypto.randomUUID()+ ownedRequest.current = requestId+ queryClient.setQueryData<RuntimeModelsState>(queryKey, { requestId, status: "pending" })+ if (connectionStatus !== "connected") {+ finishError(requestId, "Reconnect to load models.")+ return+ }+ const { token } = origin.begin()+ void origin.request(token, `/api/community/machines/${encodeURIComponent(machineId)}/discover-models`, {+ method: "POST", body: JSON.stringify({ requestId, runtimeId }),+ }).catch((error: unknown) => {+ if (isAbortError(error)) return+ const message = error instanceof Error ? error.message : "Could not load models."+ finishError(requestId, message === "UPGRADE_REQUIRED" ? "Update this machine’s daemon to load models."+ : message === "MACHINE_OFFLINE" ? "This machine is offline." : message)+ })+ }++ useEffect(() => {+ if (data?.status !== "pending") return+ if (connectionStatus !== "connected") {+ finishError(data.requestId, "Connection lost. Retry to load models.")+ return+ }+ const timer = setTimeout(() => finishError(data.requestId, "Model discovery timed out. Retry to load models."), 45_000)+ return () => clearTimeout(timer)+ }, [data?.requestId, data?.status, connectionStatus, finishError])++ useEffect(() => cancel, [cancel])++ return {+ isPending: data?.status === "pending",+ error: data?.status === "error" ? data.message : null,+ onOpenChange: (open: boolean) => open ? discover() : cancel(),+ retry: discover,+ }+}diff --git a/src/web/src/lib/query-keys.ts b/src/web/src/lib/query-keys.tsindex e21fb6878..7c7b8d83e 100644--- a/src/web/src/lib/query-keys.ts+++ b/src/web/src/lib/query-keys.ts@@ -148,6 +148,8 @@ export const communityKeys = {// ── Machines / daemons ──────────────────────────────────────────────────machines: () => [...communityKeys.all, "machines"] as const,+ runtimeModels: (machineId: string, runtimeId: string) =>+ [...communityKeys.machines(), machineId, "runtime-models", runtimeId] as const,// ── Bots ────────────────────────────────────────────────────────────────bots: () => [...communityKeys.all, "bots"] as const,diff --git a/src/web/src/test/e2e-ui/46-community-loading-geometry-android.spec.ts b/src/web/src/test/e2e-ui/46-community-loading-geometry-android.spec.tsindex e6103ebcf..14af25bf1 100644--- a/src/web/src/test/e2e-ui/46-community-loading-geometry-android.spec.ts+++ b/src/web/src/test/e2e-ui/46-community-loading-geometry-android.spec.ts@@ -52,6 +52,29 @@ for (const streamFirst of [false, true]) {})}+test("SSR fixture classifies a stream promoted between visibility reads", async ({ page }) => {+ await page.setContent(frameHtml("fallback") + `<div hidden id="S:0">${frameHtml("stream")}</div>`)+ await page.evaluate(() => {+ const streamed = document.querySelector<HTMLElement>('[data-owner="stream"]')!+ const getStyle = window.getComputedStyle.bind(window)+ window.getComputedStyle = (element, pseudo) => {+ const style = getStyle(element, pseudo)+ if (element === streamed) {+ window.getComputedStyle = getStyle+ queueMicrotask(() => {+ document.querySelector('[data-owner="fallback"]')!.remove()+ const segment = document.getElementById("S:0")!+ segment.replaceWith(...segment.childNodes)+ })+ }+ return style+ }+ })+ const frame = await expectUniqueSsrInitialFrame(page)+ await expect(frame).toHaveAttribute("data-owner", "stream")+ await expect(page.getByTestId(tid.initialFrame)).toHaveCount(1)+})+test("SSR fixture rejects two visible frames without waiting for retirement", async ({ page }) => {await page.setContent(frameHtml("fallback") + frameHtml("duplicate"))await expect(expectUniqueSsrInitialFrame(page)).rejects.toThrow(diff --git a/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts b/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.tsindex 9e9a8b004..6b55fa11b 100644--- a/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts+++ b/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts@@ -1152,7 +1152,8 @@ test.describe("message scroll characterization", () => {const actors = await caseActors(["alice", "bob", "carol"])const asUser = tracedAsUser(actors)const { userId } = actors- const { composerDmId, composerDmProfile } = await seedScrollCase(actors)+ const composerDmId = await actors.seed.seedDm("alice", userId("bob"))+ const composerDmProfile = await seedDmProfile(actors, composerDmId, 36)const alice = await asUser("alice")await alice.page.setViewportSize(VIEWPORT)diff --git a/src/web/src/test/e2e-ui/_fixtures/community-ssr-frame.ts b/src/web/src/test/e2e-ui/_fixtures/community-ssr-frame.tsindex 75045bf48..8851bdf3c 100644--- a/src/web/src/test/e2e-ui/_fixtures/community-ssr-frame.ts+++ b/src/web/src/test/e2e-ui/_fixtures/community-ssr-frame.ts@@ -4,29 +4,33 @@ import { tid } from "./testids"export async function expectUniqueSsrInitialFrame(page: Page) {const frames = page.getByTestId(tid.initialFrame)const visibleFrame = frames.filter({ visible: true })- let visibleCount = 0- await expect.poll(async () => {- visibleCount = await visibleFrame.count()- return visibleCount- }).toBeGreaterThan(0)- expect(- visibleCount,- "SSR must have exactly one visible initial frame",- ).toBe(1)- const hiddenState = await frames.filter({ visible: false }).evaluateAll((elements) => ({+ const readState = () => page.evaluate((testId) => ({readyState: document.readyState,- nodes: elements.map((element) => {+ nodes: Array.from(document.querySelectorAll(`[data-testid="${CSS.escape(testId)}"]`)).map((element) => {+ const rect = element.getBoundingClientRect()+ const style = getComputedStyle(element)const stream = element.parentElement?.closest('[hidden][id^="S:"]')return {+ visible: rect.width > 0 && rect.height > 0+ && style.visibility !== "hidden" && style.visibility !== "collapse",routeKind: element.getAttribute("data-community-route-kind"),streamId: stream?.id ?? null,streamDisplay: stream ? getComputedStyle(stream).display : null,}}),- }))+ }), tid.initialFrame)+ let state: Awaited<ReturnType<typeof readState>> | undefined+ await expect.poll(async () => {+ state = await readState()+ return state.nodes.filter((node) => node.visible).length+ }).toBeGreaterThan(0)+ expect(+ state!.nodes.filter((node) => node.visible).length,+ "SSR must have exactly one visible initial frame",+ ).toBe(1)expect(- hiddenState.nodes.filter((node) => node.streamId === null || node.streamDisplay !== "none"),- `Unexpected hidden SSR initial frame: ${JSON.stringify(hiddenState)}`,+ state!.nodes.filter((node) => !node.visible && (node.streamId === null || node.streamDisplay !== "none")),+ `Unexpected hidden SSR initial frame: ${JSON.stringify(state)}`,).toEqual([])await expect(visibleFrame).toBeVisible()return visibleFramediff --git a/src/ws-do/src/community-browser-event-ingress.test.ts b/src/ws-do/src/community-browser-event-ingress.test.tsindex 5164b47a3..74b19b9fd 100644--- a/src/ws-do/src/community-browser-event-ingress.test.ts+++ b/src/ws-do/src/community-browser-event-ingress.test.ts@@ -69,9 +69,9 @@ function worstEscapingTarget(index: number) {}describe("community browser event ingress", () => {- it("normalizes all 46 current fixtures without a contract version field", () => {+ it("normalizes all 47 current fixtures without a contract version field", () => {const fixtures = Object.values(communityWsEventFixtures)- expect(fixtures).toHaveLength(46)+ expect(fixtures).toHaveLength(47)for (const fixture of fixtures) {const normalized = normalizeCommunityBrowserEvent(fixture)expect(normalized).toMatchObject({ ok: true, event: fixture, envelope: fixture })diff --git a/src/ws-do/src/community-browser-event-ingress.ts b/src/ws-do/src/community-browser-event-ingress.tsindex a2d00cdc1..dcc896b7e 100644--- a/src/ws-do/src/community-browser-event-ingress.ts+++ b/src/ws-do/src/community-browser-event-ingress.ts@@ -1,3 +1,4 @@+import { readBoundedJsonRequest as readBoundedHttpJsonRequest } from "@alook/shared"import {COMMUNITY_BROWSER_EVENT_MAX_BYTES,COMMUNITY_CONTRACT_HEADER,@@ -42,56 +43,9 @@ export type BoundedJsonResult =| { ok: true; value: unknown; byteCount: number }| CommunityBrowserEventIngressFailure-function oversized(byteCount: number): CommunityBrowserEventIngressFailure {- return { ok: false, reason: "oversized", type: "unknown", byteCount }-}--export async function readBoundedJsonRequest(- request: Request,- maxBytes: number,-): Promise<BoundedJsonResult> {- const contentLength = request.headers.get("content-length")- if (contentLength !== null) {- const declared = Number(contentLength)- if (Number.isSafeInteger(declared) && declared > maxBytes) return oversized(declared)- }- const reader = request.body?.getReader()- if (!reader) return { ok: false, reason: "invalid-json", type: "unknown", byteCount: 0 }- const chunks: Uint8Array[] = []- let byteCount = 0- try {- while (true) {- const { done, value } = await reader.read()- if (done) break- byteCount += value.byteLength- if (byteCount > maxBytes) {- try {- await reader.cancel()- } catch {}- return oversized(byteCount)- }- chunks.push(value)- }- } catch {- return { ok: false, reason: "invalid-json", type: "unknown", byteCount }- }- const bytes = new Uint8Array(byteCount)- let offset = 0- for (const chunk of chunks) {- bytes.set(chunk, offset)- offset += chunk.byteLength- }- let text: string- try {- text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes)- } catch {- return { ok: false, reason: "invalid-json", type: "unknown", byteCount }- }- try {- return { ok: true, value: JSON.parse(text), byteCount }- } catch {- return { ok: false, reason: "invalid-json", type: "unknown", byteCount }- }+export async function readBoundedJsonRequest(request: Request, maxBytes: number): Promise<BoundedJsonResult> {+ const parsed = await readBoundedHttpJsonRequest(request, maxBytes)+ return parsed.ok ? parsed : { ...parsed, type: "unknown" }}export function normalizeCommunityBrowserEvent(diff --git a/src/ws-do/src/community-content-access.ts b/src/ws-do/src/community-content-access.tsindex 22d0b6dee..5b1af59b8 100644--- a/src/ws-do/src/community-content-access.ts+++ b/src/ws-do/src/community-content-access.ts@@ -47,6 +47,7 @@ export const communityContentAccessKinds = {"community:machine.created": "control","community:machine.status": "control","community:machine.updated": "control",+ "community:runtime.models": "control","community:machine.removed": "control","community:bot.audit_event": "control",} as const satisfies Record<CommunityWsEvent["type"], AccessKind>diff --git a/src/ws-do/src/index.test.ts b/src/ws-do/src/index.test.tsindex b0bac8ea7..60ec38f64 100644--- a/src/ws-do/src/index.test.ts+++ b/src/ws-do/src/index.test.ts@@ -84,6 +84,7 @@ describe("ws-do router", () => {"handleAuditBroadcast","handleBatchPresence","handleSinglePresence",+ "handleMachineModels","handleMachinePush","handleMachineWake","handleMachineDiagnostics",diff --git a/src/ws-do/src/index.ts b/src/ws-do/src/index.tsindex 2dd3eb793..2be6b8a56 100644--- a/src/ws-do/src/index.ts+++ b/src/ws-do/src/index.ts@@ -1,3 +1,4 @@+import { handleMachineModels } from "./routes/community-machine-models"import { handleAuditBroadcast } from "./routes/audit-broadcast"import {handleCommunityUserBroadcast,@@ -66,6 +67,8 @@ export default {if (response) return responseresponse = await handleSinglePresence(context)if (response) return response+ response = await handleMachineModels(context)+ if (response) return responseresponse = await handleMachinePush(context)if (response) return responseresponse = await handleMachineWake(context)diff --git a/src/ws-do/src/routes/community-machine-models.test.ts b/src/ws-do/src/routes/community-machine-models.test.tsnew file mode 100644index 000000000..f09772073--- /dev/null+++ b/src/ws-do/src/routes/community-machine-models.test.ts@@ -0,0 +1,35 @@+import { beforeEach, describe, expect, it, vi } from "vitest"+import { createRouterTestContext, getSharedMocks, loadRouter } from "./test-harness"+const mocks = getSharedMocks()+describe("model discovery worker routing", () => {+ beforeEach(() => { vi.clearAllMocks(); mocks.getActiveDoNamesForMachine.mockResolvedValue(["credential"]) })+ const request = (body = { requestId: "request", runtimeId: "codex" }) => new Request("http://localhost/community-machine/by-id/machine/discover-models", { method: "POST", body: JSON.stringify(body) })+ it("resolves the current credential and forwards only the selected runtime command", async () => {+ const { env, doMock } = createRouterTestContext()+ doMock.stubFetch.mockResolvedValue(Response.json({ sent: 1, unsupported: 0 }))+ const response = await (await loadRouter()).fetch(request(), env as any)+ expect(await response.json()).toEqual({ sent: 1, unsupported: 0 })+ expect(mocks.getActiveDoNamesForMachine).toHaveBeenCalledWith({}, "machine")+ expect(doMock.idFromName).toHaveBeenCalledWith("community-machine:credential")+ const forwarded = doMock.stubFetch.mock.calls[0][0] as Request+ expect(new URL(forwarded.url).pathname).toBe("/discover-models")+ expect(await forwarded.json()).toEqual({ type: "runtime:discover_models", requestId: "request", runtimeId: "codex" })+ })+ it("reports credential lookup failures as unavailable", async () => {+ const { env, doMock } = createRouterTestContext()+ mocks.getActiveDoNamesForMachine.mockRejectedValue(new Error("d1"))+ expect((await (await loadRouter()).fetch(request(), env as any)).status).toBe(503)+ expect(doMock.stubFetch).not.toHaveBeenCalled()+ })+ it("returns zero for a machine with no current credential", async () => {+ const { env, doMock } = createRouterTestContext()+ mocks.getActiveDoNamesForMachine.mockResolvedValue([])+ expect(await (await (await loadRouter()).fetch(request(), env as any)).json()).toEqual({ sent: 0, unsupported: 0 })+ expect(doMock.stubFetch).not.toHaveBeenCalled()+ })+ it("rejects corrupt receipts instead of claiming a delivered request", async () => {+ const { env, doMock } = createRouterTestContext()+ doMock.stubFetch.mockResolvedValue(Response.json({ sent: "1", unsupported: 0 }))+ expect((await (await loadRouter()).fetch(request(), env as any)).status).toBe(503)+ })+})diff --git a/src/ws-do/src/routes/community-machine-models.ts b/src/ws-do/src/routes/community-machine-models.tsnew file mode 100644index 000000000..57305d62a--- /dev/null+++ b/src/ws-do/src/routes/community-machine-models.ts@@ -0,0 +1,34 @@+import { createDb, queries, RuntimeModelDiscoveryRequestSchema } from "@alook/shared"+import { readBoundedJsonRequest } from "../community-browser-event-ingress"+import type { RouterContext } from "../router-context"++export async function handleMachineModels({ request, env, url }: RouterContext): Promise<Response | null> {+ const match = url.pathname.match(/^\/community-machine\/by-id\/([^/]+)\/discover-models$/)+ if (!match || request.method !== "POST") return null+ const input = await readBoundedJsonRequest(request, 4096)+ const payload = RuntimeModelDiscoveryRequestSchema.safeParse(input.ok ? input.value : null)+ if (!payload.success) return Response.json({ error: "invalid request" }, { status: 400 })+ try {+ const machineId = decodeURIComponent(match[1])+ const doNames = await queries.communityMachine.getActiveDoNamesForMachine(createDb(env.DB), machineId)+ let sent = 0+ let unsupported = 0+ for (const name of doNames) {+ const stub = env.WS_DO.get(env.WS_DO.idFromName("community-machine:" + name))+ const response = await stub.fetch(new Request("http://internal/discover-models", {+ method: "POST",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({ type: "runtime:discover_models", ...payload.data }),+ }))+ if (!response.ok) throw new Error("dispatch failed")+ const receipt = await response.json() as { sent?: unknown; unsupported?: unknown }+ if (!Number.isSafeInteger(receipt.sent) || (receipt.sent as number) < 0+ || !Number.isSafeInteger(receipt.unsupported) || (receipt.unsupported as number) < 0) throw new Error("invalid receipt")+ sent += receipt.sent as number+ unsupported += receipt.unsupported as number+ }+ return Response.json({ sent, unsupported })+ } catch {+ return Response.json({ error: "model discovery dispatch unavailable" }, { status: 503 })+ }+}diff --git a/src/ws-do/src/ws-durable/internal.ts b/src/ws-do/src/ws-durable/internal.tsindex b6a567b84..aa3f76e53 100644--- a/src/ws-do/src/ws-durable/internal.ts+++ b/src/ws-do/src/ws-durable/internal.ts@@ -27,6 +27,7 @@ export type ConnectionState =machineId: stringuserId: stringauthenticated: boolean+ modelDiscovery?: booleancontrolHeartbeat?: booleanlastHeartbeatAckAt?: numberpendingHeartbeatNonce?: stringdiff --git a/src/ws-do/src/ws-durable/machine-control.test.ts b/src/ws-do/src/ws-durable/machine-control.test.tsindex f21032dff..18634ef74 100644--- a/src/ws-do/src/ws-durable/machine-control.test.ts+++ b/src/ws-do/src/ws-durable/machine-control.test.ts@@ -483,3 +483,31 @@ describe("WebSocketDurableObject", () => {})})})+++describe("on-demand model discovery dispatch", () => {+ beforeEach(() => resetHarness())+ afterEach(() => cleanupHarness())+ it("sends only to authenticated capable daemon sockets", async () => {+ const { durable, getWebSockets } = createDO()+ const sockets = [true, false, true].map((modelDiscovery, index) => {+ const socket = createMockWebSocket()+ socket.serializeAttachment({ type: "community-machine", authenticated: index !== 2, machineId: "machine", userId: "owner", modelDiscovery })+ return socket+ })+ getWebSockets.mockReturnValue(sockets)+ const response = await durable.fetch(new Request("http://internal/discover-models", { method: "POST", body: JSON.stringify({ type: "runtime:discover_models", runtimeId: "codex", requestId: "request" }) }))+ expect(await response.json()).toEqual({ sent: 1, unsupported: 1 })+ expect(JSON.parse(sockets[0].send.mock.calls[0][0])).toEqual({ type: "runtime:discover_models", runtimeId: "codex", requestId: "request" })+ expect(sockets[1].send).not.toHaveBeenCalled()+ expect(sockets[2].send).not.toHaveBeenCalled()+ })+ it("rejects extra command fields without socket delivery", async () => {+ const { durable, getWebSockets } = createDO()+ const socket = createMockWebSocket()+ getWebSockets.mockReturnValue([socket])+ const response = await durable.fetch(new Request("http://internal/discover-models", { method: "POST", body: JSON.stringify({ type: "runtime:discover_models", runtimeId: "codex", requestId: "request", agentId: "bot" }) }))+ expect(response.status).toBe(400)+ expect(socket.send).not.toHaveBeenCalled()+ })+})diff --git a/src/ws-do/src/ws-durable/machine-control.ts b/src/ws-do/src/ws-durable/machine-control.tsindex 23d4c9431..952cb2449 100644--- a/src/ws-do/src/ws-durable/machine-control.ts+++ b/src/ws-do/src/ws-durable/machine-control.ts@@ -1,4 +1,5 @@-import { createDb, DiagnosticCollectCommandSchema, queries } from "@alook/shared"+import { readBoundedJsonRequest } from "../community-browser-event-ingress"+import { createDb, DiagnosticCollectCommandSchema, RuntimeModelDiscoveryCommandSchema, queries } from "@alook/shared"import {HANDLE_KEY,IDENTITY_KEY,@@ -33,9 +34,17 @@ export async function handleMachineControlFetch(})}+ if (url.pathname === "/discover-models" && request.method === "POST") {+ const input = await readBoundedJsonRequest(request, 4096)+ const command = RuntimeModelDiscoveryCommandSchema.safeParse(input.ok ? input.value : null)+ if (!command.success) return new Response(JSON.stringify({ error: "invalid request" }), { status: 400, headers: { "Content-Type": "application/json" } })+ const { sent, unsupported } = forwardToCommunityMachine(context, JSON.stringify(command.data), true)+ return new Response(JSON.stringify({ sent, unsupported }), { headers: { "Content-Type": "application/json" } })+ }+if (url.pathname === "/push" && request.method === "POST") {const body = await request.text()- const sent = forwardToCommunityMachine(context, body)+ const sent = forwardToCommunityMachine(context, body).sentif (sent > 0) await hooks.recordPendingRestarts(body)return new Response(JSON.stringify({ sent }), {headers: { "Content-Type": "application/json" },@@ -78,7 +87,7 @@ export async function handleMachineControlFetch(config,launchId,})- const sent = forwardToCommunityMachine(context, frame)+ const sent = forwardToCommunityMachine(context, frame).sentif (sent > 0) {const attribution: RestartAttribution = providerSwitch? { kind: "provider_switch", from: from as string, to: to as string }@@ -112,7 +121,7 @@ export async function handleMachineControlFetch(type: "agent:runtime_config_update",agentId: raw.agentId,config: raw.config,- }))+ })).sentreturn new Response(JSON.stringify({ sent }), {headers: { "Content-Type": "application/json" },})@@ -120,7 +129,7 @@ export async function handleMachineControlFetch(if (url.pathname === "/forward-agent-wake" && request.method === "POST") {const body = await request.text()- const attempted = forwardToCommunityMachine(context, body)+ const attempted = forwardToCommunityMachine(context, body).sentawait hooks.clearRuntimeErrorOverlay().catch(() => { })return new Response(JSON.stringify({ attempted, sent: attempted }), {headers: { "Content-Type": "application/json" },@@ -162,7 +171,7 @@ export async function handleMachineControlFetch(if (!command.success) {return new Response(JSON.stringify({ attempted: 0 }), { status: 400 })}- const attempted = forwardToCommunityMachine(context, JSON.stringify(command.data))+ const attempted = forwardToCommunityMachine(context, JSON.stringify(command.data)).sentreturn new Response(JSON.stringify({ attempted, sent: attempted }), {headers: { "Content-Type": "application/json" },})@@ -263,16 +272,18 @@ function rejectCommunityMachine(ws: WebSocket, reason: string): void {try { ws.close(1008, "Unauthorized") } catch { /* ok */ }}-function forwardToCommunityMachine(context: WsDurableContext, message: string): number {+function forwardToCommunityMachine(context: WsDurableContext, message: string, requireModelDiscovery = false): { sent: number; unsupported: number } {let sent = 0+ let unsupported = 0for (const ws of context.ctx.getWebSockets()) {const state = ws.deserializeAttachment() as ConnectionStateif (state?.type === "community-machine" && state.authenticated) {+ if (requireModelDiscovery && !state.modelDiscovery) { unsupported++; continue }try {ws.send(message)sent++} catch { /* ok */ }}}- return sent+ return { sent, unsupported }}diff --git a/src/ws-do/src/ws-durable/machine-frames.ts b/src/ws-do/src/ws-durable/machine-frames.tsindex 716bc93f8..8360c4aed 100644--- a/src/ws-do/src/ws-durable/machine-frames.ts+++ b/src/ws-do/src/ws-durable/machine-frames.ts@@ -1,3 +1,4 @@+import { handleRuntimeModelsFrame } from "./machine-models"import { IDENTITY_KEY } from "./internal"import type { CommunityMachineIdentity, WsDurableContext } from "./internal"import { handleReadyFrame } from "./machine-ready"@@ -76,6 +77,7 @@ export async function handleCommunityMachineMessage(parsed,identity,)) return+ if (await handleRuntimeModelsFrame(context, parsed, identity)) returnawait handleReadyFrame(context,parsed,diff --git a/src/ws-do/src/ws-durable/machine-models.test.ts b/src/ws-do/src/ws-durable/machine-models.test.tsnew file mode 100644index 000000000..a35df64e7--- /dev/null+++ b/src/ws-do/src/ws-durable/machine-models.test.ts@@ -0,0 +1,60 @@+import { afterEach, beforeEach, describe, expect, it } from "vitest"+import { createMockWebSocket } from "../__mocks__/cf"+import { cleanupHarness, createDO, mockUpsertMachineByMachineId, mockTouchMachineHeartbeat, mockStubFetch, mockGetMachineByIdForUser, resetHarness } from "./test-harness"+const identity = { userId: "owner", machineId: "machine", credentialHash: "a".repeat(64) }+const catalog = { updateMode: "unsupported", models: [{ id: "native-model", supportedReasoningEfforts: [] }] }+const frame = { type: "runtime_models", runtimeId: "codex", requestId: "request", result: { status: "complete", runtimeReport: [{ id: "codex", status: "healthy", reasoning: catalog }] } }+function setup() {+ const state = createDO()+ state.store.set("community-machine-identity", identity)+ const socket = createMockWebSocket()+ socket.serializeAttachment({ type: "community-machine", authenticated: true, ...identity })+ return { ...state, socket }+}+describe("model discovery frames", () => {+ beforeEach(() => {+ resetHarness()+ mockUpsertMachineByMachineId.mockResolvedValue({ machine: { id: "machine" } })+ mockTouchMachineHeartbeat.mockResolvedValue({ machine: { id: "machine" } })+ mockGetMachineByIdForUser.mockResolvedValue(null)+ mockStubFetch.mockClear()+ })+ afterEach(() => cleanupHarness())+ it("persists under the credential epoch before notifying only the owner", async () => {+ const { durable, socket, env } = setup()+ await durable.webSocketMessage(socket as any, JSON.stringify(frame))+ expect(mockUpsertMachineByMachineId).toHaveBeenCalledWith(expect.anything(), "owner", "machine", { availableRuntimes: frame.result.runtimeReport }, identity.credentialHash)+ expect(mockUpsertMachineByMachineId.mock.invocationCallOrder[0]).toBeLessThan(mockStubFetch.mock.invocationCallOrder[0])+ expect(env.WS_DO.idFromName).toHaveBeenCalledWith("user:owner")+ expect(mockGetMachineByIdForUser).not.toHaveBeenCalled()+ expect(mockStubFetch).toHaveBeenCalledTimes(1)+ const request = mockStubFetch.mock.calls[0][0] as Request+ expect(await request.json()).toMatchObject({ type: "community:runtime.models", machineId: "machine", runtimeId: "codex", requestId: "request", result: { status: "complete", catalog } })+ })+ it("drops results from revoked epochs", async () => {+ mockUpsertMachineByMachineId.mockResolvedValue(null)+ const { durable, socket } = setup()+ await durable.webSocketMessage(socket as any, JSON.stringify(frame))+ expect(mockStubFetch).not.toHaveBeenCalled()+ })+ it("reports persistence failure without claiming a discovered catalog", async () => {+ mockUpsertMachineByMachineId.mockRejectedValue(new Error("private db error"))+ const { durable, socket } = setup()+ await durable.webSocketMessage(socket as any, JSON.stringify(frame))+ expect(await (mockStubFetch.mock.calls[0][0] as Request).json()).toMatchObject({ result: { status: "error", code: "model_discovery_failed" } })+ })+ it("fences an error response without replacing runtime catalogs", async () => {+ const { durable, socket } = setup()+ await durable.webSocketMessage(socket as any, JSON.stringify({ ...frame, result: { status: "error", code: "auth_required", message: "Sign in" } }))+ expect(mockTouchMachineHeartbeat).toHaveBeenCalledWith(expect.anything(), "owner", "machine", identity.credentialHash)+ expect(mockUpsertMachineByMachineId).not.toHaveBeenCalled()+ expect(await (mockStubFetch.mock.calls[0][0] as Request).json()).toMatchObject({ result: { status: "error", code: "auth_required" } })+ })+ it("drops malformed or mismatched-runtime results", async () => {+ const { durable, socket } = setup()+ await durable.webSocketMessage(socket as any, JSON.stringify({ ...frame, runtimeId: "missing" }))+ await durable.webSocketMessage(socket as any, JSON.stringify({ ...frame, requestId: "" }))+ expect(mockUpsertMachineByMachineId).not.toHaveBeenCalled()+ expect(mockStubFetch).not.toHaveBeenCalled()+ })+})diff --git a/src/ws-do/src/ws-durable/machine-models.ts b/src/ws-do/src/ws-durable/machine-models.tsnew file mode 100644index 000000000..72381fb2c--- /dev/null+++ b/src/ws-do/src/ws-durable/machine-models.ts@@ -0,0 +1,41 @@+import { createDb, HostRuntimeModelsFrameSchema, queries, WS_EVENTS, type RuntimeModelDiscoveryResult } from "@alook/shared"+import type { CommunityMachineIdentity, WsDurableContext } from "./internal"+import { notifyUserDO } from "./presence-typing"++export async function handleRuntimeModelsFrame(+ context: WsDurableContext,+ parsed: unknown,+ identity: CommunityMachineIdentity,+): Promise<boolean> {+ if (!parsed || typeof parsed !== "object" || (parsed as { type?: unknown }).type !== "runtime_models") return false+ const input = HostRuntimeModelsFrameSchema.safeParse(parsed)+ if (!input.success) return true+ const frame = input.data+ const runtime = frame.result.status === "complete"+ ? frame.result.runtimeReport.find((item) => item.id === frame.runtimeId)+ : undefined+ if (frame.result.status === "complete" && !runtime) return true+ let result: RuntimeModelDiscoveryResult = frame.result.status === "error"+ ? frame.result+ : { status: "complete", catalog: runtime?.reasoning ?? null }+ try {+ const db = createDb(context.env.DB)+ const transition = await queries.communityMachineSession.transitionMachineSessionEpoch(db,+ frame.result.status === "complete"+ ? { type: "ready", epoch: identity, metadata: { availableRuntimes: frame.result.runtimeReport } }+ : { type: "renew", epoch: identity },+ )+ if (transition.type === "stale_epoch") return true+ } catch {+ context.log.warn("runtime model discovery persistence failed", { machineId: identity.machineId, runtimeId: frame.runtimeId })+ result = { status: "error", code: "model_discovery_failed", message: "Could not save the discovered models" }+ }+ await notifyUserDO(context, identity.userId, {+ type: WS_EVENTS.RUNTIME_MODELS,+ machineId: identity.machineId,+ requestId: frame.requestId,+ runtimeId: frame.runtimeId,+ result,+ })+ return true+}diff --git a/src/ws-do/src/ws-durable/machine-ready.ts b/src/ws-do/src/ws-durable/machine-ready.tsindex cef877372..6c85d65c1 100644--- a/src/ws-do/src/ws-durable/machine-ready.ts+++ b/src/ws-do/src/ws-durable/machine-ready.ts@@ -1,5 +1,6 @@import {CONTROL_HEARTBEAT_CAPABILITY,+ RUNTIME_MODEL_DISCOVERY_CAPABILITY,createDb,HostReadyMessageSchema,ProviderQuotaSnapshotSchema,@@ -94,6 +95,7 @@ export async function handleReadyFrame(ws.serializeAttachment({...state,controlHeartbeat,+ modelDiscovery: ready.capabilities.includes(RUNTIME_MODEL_DISCOVERY_CAPABILITY),...(controlHeartbeat ? { lastHeartbeatAckAt: Date.now() } : {}),pendingHeartbeatNonce: undefined,})diff --git a/src/ws-do/src/ws-durable/test-harness.ts b/src/ws-do/src/ws-durable/test-harness.tsindex 1e3d9ff95..b7dca1725 100644--- a/src/ws-do/src/ws-durable/test-harness.ts+++ b/src/ws-do/src/ws-durable/test-harness.ts@@ -316,6 +316,7 @@ vi.mock("@alook/shared", async () => {TYPING_STOP: "community:typing.stop",MACHINE_STATUS: "community:machine.status",MACHINE_UPDATED: "community:machine.updated",+ RUNTIME_MODELS: "community:runtime.models",STATUS_UPDATE: "community:status.update",BOT_AUDIT_EVENT: "community:bot.audit_event",PRESENCE_UPDATE: "community:presence.update",