Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
chore(agents): don't lie about agents in harness panel in settings (#6191)
Wolf Mermelsteine66270d12267
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex ad2d65c0c8..885261328c 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -283,6 +283,7 @@"crates/github","crates/harness_id","crates/harness_token",+ "crates/harnesses","crates/import","crates/invite_email","crates/item_filters",diff --git a/Cargo.lock b/Cargo.lockindex fc2081278c..4edbc22b50 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -281,6 +281,7 @@ dependencies = ["tracing","tracing-opentelemetry","url",+ "utoipa","workspace-hack",]@@ -288,6 +289,7 @@ dependencies = [name = "agent_harness_service"version = "0.1.0"dependencies = [+ "agent-client-protocol","agent_egress","agent_fold","agent_harness",@@ -315,6 +317,7 @@ dependencies = ["futures","github","harness_id",+ "harnesses","kafka_util","lexical_client","macro_auth",@@ -369,6 +372,7 @@ dependencies = ["axum","bot_id","bytes",+ "chat","dashmap","futures","http 1.4.0",@@ -7567,7 +7571,6 @@ dependencies = ["model-error-response","rand 0.9.4","serde",- "serde_json","sqlx","thiserror 2.0.18","tokio",diff --git a/apps/web/src/features/settings/Agents.test.tsx b/apps/web/src/features/settings/Agents.test.tsxindex 02baff5985..29c78c7464 100644--- a/apps/web/src/features/settings/Agents.test.tsx+++ b/apps/web/src/features/settings/Agents.test.tsx@@ -3,8 +3,8 @@*/import { Model } from '@core/component/AI/constant/model';-import { useCursorModelsQuery } from '@queries/auth/cursor-api-key';-import type { CursorModelsResponse } from '@service-auth/generated/schemas';+import { useAgentModelsQueries } from '@queries/agents/models';+import type { LoadAgentModelsResponse } from '@service-agent-harness/generated/schemas';import {fireEvent,render,@@ -30,17 +30,6 @@ const cursorMocks = vi.hoisted(() => ({updatedAt: null as string | null,},},- models: {- isSuccess: true,- isPending: false,- isError: false,- data: {- models: [- { id: 'cursor-small', displayName: 'Cursor Small' },- { id: 'cursor-large', displayName: 'Cursor Large' },- ],- },- },}));const agentMocks = vi.hoisted(() => ({@@ -62,9 +51,69 @@ const agentMocks = vi.hoisted(() => ({vi.mock('@queries/auth/cursor-api-key', () => ({useCursorApiKeyStatusQuery: () => cursorMocks.status,- useCursorModelsQuery: vi.fn(() => cursorMocks.models),}));+const modelMocks = vi.hoisted(() => ({+ queries: {} as Record<+ string,+ {+ data?: {+ status: 'available' | 'unsupported';+ currentModel?: string | null;+ models: { id: string; name: string; description?: string | null }[];+ };+ isPending: boolean;+ isError: boolean;+ isSuccess: boolean;+ refetch: ReturnType<typeof vi.fn>;+ }+ >,+}));++function modelTargetKey(target: {+ harness: string;+ harnessId?: string;+}): string {+ return `${target.harness}:${target.harnessId ?? ''}`;+}++function successfulModels(+ models: { id: string; name: string }[],+ currentModel = models[0]?.id+) {+ return {+ data: {+ status: 'available' as const,+ currentModel,+ models,+ },+ isPending: false,+ isError: false,+ isSuccess: true,+ refetch: vi.fn(),+ };+}++vi.mock('@queries/agents/models', async (importOriginal) => {+ const actual =+ await importOriginal<typeof import('@queries/agents/models')>();+ return {+ ...actual,+ useAgentModelsQueries: vi.fn(+ (targets: () => { harness: string; harnessId?: string }[]) =>+ targets().map(+ (target) =>+ modelMocks.queries[modelTargetKey(target)] ?? {+ isPending: true,+ isError: false,+ isSuccess: false,+ refetch: vi.fn(),+ }+ )+ ),+ };+});+const harnessMocks = vi.hoisted(() => ({query: {isSuccess: true,@@ -206,6 +255,12 @@ beforeEach(() => {return 'connected';});+ modelMocks.queries = {+ 'in-memory:': successfulModels([+ { id: Model.sonnet5, name: 'Claude Sonnet 4.5' },+ { id: Model.opus5, name: 'Claude Opus 4.5' },+ ]),+ };});const MACROD_HARNESS = {@@ -225,20 +280,27 @@ describe('Agents', () => {'keeps settings visible while Cursor models load and after %s',async (outcome) => {cursorMocks.status.data.registered = true;- let resolveModels!: (models: CursorModelsResponse) => void;+ let resolveModels!: (models: LoadAgentModelsResponse) => void;let rejectModels!: (error: Error) => void;- const response = new Promise<CursorModelsResponse>((resolve, reject) => {- resolveModels = resolve;- rejectModels = reject;- });+ const response = new Promise<LoadAgentModelsResponse>(+ (resolve, reject) => {+ resolveModels = resolve;+ rejectModels = reject;+ }+ );const client = new QueryClient({defaultOptions: { queries: { retry: false } },});- vi.mocked(useCursorModelsQuery).mockImplementationOnce(() =>- useQuery(() => ({- queryKey: ['pending-cursor-models'],- queryFn: () => response,- }))+ vi.mocked(useAgentModelsQueries).mockImplementationOnce((targets) =>+ targets().map((target) =>+ useQuery(() => ({+ queryKey: ['pending-models', target.harness],+ queryFn: () =>+ target.harness === 'cursor'+ ? response+ : Promise.resolve(successfulModels([]).data),+ }))+ ));const view = render(() => (<QueryClientProvider client={client}>@@ -264,22 +326,22 @@ describe('Agents', () => {if (outcome === 'error') {rejectModels(new Error('Cursor is unavailable'));await waitFor(() =>- expect(screen.getByText(/Could not load Cursor models/)).toBeTruthy()+ expect(+ screen.getByText(/Could not load models for Cursor/)+ ).toBeTruthy());expect(screen.queryByText('Settings suspended')).toBeNull();expect(- (- screen.getByRole('combobox', {- name: 'Default model',- }) as HTMLSelectElement- ).disabled- ).toBe(true);+ screen.getByRole('button', { name: 'Retry models for Cursor' })+ ).toBeTruthy();} else {resolveModels({+ status: 'available',+ currentModel: 'loaded-model',models: [{id: 'loaded-model',- displayName: 'Loaded Model',+ name: 'Loaded Model',group: 'Cursor',},],@@ -686,6 +748,10 @@ describe('Agents', () => {registered: true,updatedAt: '2026-08-27T12:00:00Z',};+ modelMocks.queries['cursor:'] = successfulModels([+ { id: 'cursor-small', name: 'Cursor Small' },+ { id: 'cursor-large', name: 'Cursor Large' },+ ]);render(() => <Agents />);fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));@@ -718,8 +784,76 @@ describe('Agents', () => {).toBeTruthy();});- it('swaps the model select for a free-text input seeded with default for macrod harnesses', () => {+ it('keeps loading, error, and unsupported states independent per harness', () => {+ cursorMocks.status.data = {+ registered: true,+ updatedAt: '2026-08-27T12:00:00Z',+ };+ const loadingHarness = {+ ...MACROD_HARNESS,+ id: '4f1c9d2e-8a4b-4c5d-9e6f-1a2b3c4d5e70',+ name: 'Loading box',+ };+ harnessMocks.query.data = [MACROD_HARNESS, loadingHarness];+ const retry = vi.fn();+ modelMocks.queries['cursor:'] = {+ isPending: false,+ isError: true,+ isSuccess: false,+ refetch: retry,+ };+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = {+ data: { status: 'unsupported', models: [] },+ isPending: false,+ isError: false,+ isSuccess: true,+ refetch: vi.fn(),+ };+ modelMocks.queries[`macrod:${loadingHarness.id}`] = {+ isPending: true,+ isError: false,+ isSuccess: false,+ refetch: vi.fn(),+ };++ render(() => <Agents />);+ fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));+ const dialog = screen.getByRole('dialog');+ const harness = within(dialog).getByLabelText('Harness');++ expect(+ within(dialog).getByRole('option', { name: 'Claude Sonnet 4.5' })+ ).toBeTruthy();++ fireEvent.change(harness, { target: { value: 'cursor' } });+ expect(+ within(dialog).getByText(/Could not load models for Cursor/)+ ).toBeTruthy();+ fireEvent.click(+ within(dialog).getByRole('button', { name: 'Retry models for Cursor' })+ );+ expect(retry).toHaveBeenCalledOnce();++ fireEvent.change(harness, { target: { value: MACROD_HARNESS.id } });+ expect(+ within(dialog).getByText(+ 'Model selection is unsupported by this harness.'+ )+ ).toBeTruthy();++ fireEvent.change(harness, { target: { value: loadingHarness.id } });+ expect(within(dialog).getByText('Loading models…')).toBeTruthy();+ });++ it('uses the discovered model selector for macrod harnesses', () => {harnessMocks.query.data = [MACROD_HARNESS];+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = successfulModels(+ [+ { id: 'claude-code', name: 'Claude Code' },+ { id: 'codex', name: 'Codex' },+ ],+ 'codex'+ );render(() => <Agents />);fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));@@ -729,12 +863,63 @@ describe('Agents', () => {fireEvent.change(harness, { target: { value: MACROD_HARNESS.id } });const defaultModel = within(dialog).getByLabelText('Default model');- expect(defaultModel.tagName).toBe('INPUT');- expect(defaultModel).toHaveProperty('value', 'default');+ expect(defaultModel.tagName).toBe('SELECT');+ expect(defaultModel).toHaveProperty('value', 'codex');+ expect(within(defaultModel).getAllByRole('option')).toHaveLength(2);+ });++ it('falls back to the first advertised model when current is absent', () => {+ harnessMocks.query.data = [MACROD_HARNESS];+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = successfulModels(+ [+ { id: 'claude-code', name: 'Claude Code' },+ { id: 'codex', name: 'Codex' },+ ],+ 'retired-model'+ );++ render(() => <Agents />);+ fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));+ const dialog = screen.getByRole('dialog');+ fireEvent.change(within(dialog).getByLabelText('Harness'), {+ target: { value: MACROD_HARNESS.id },+ });++ expect(within(dialog).getByLabelText('Default model')).toHaveProperty(+ 'value',+ 'claude-code'+ );+ });++ it('shows the current model when an available catalog has no options', () => {+ harnessMocks.query.data = [MACROD_HARNESS];+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = successfulModels(+ [],+ 'provider-default'+ );++ render(() => <Agents />);+ fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));+ const dialog = screen.getByRole('dialog');+ fireEvent.change(within(dialog).getByLabelText('Harness'), {+ target: { value: MACROD_HARNESS.id },+ });++ const defaultModel = within(dialog).getByLabelText('Default model');+ expect(defaultModel).toHaveProperty('value', 'provider-default');+ expect(+ within(defaultModel).getByRole('option', {+ name: 'provider-default (unavailable)',+ })+ ).toBeTruthy();});it('submits macrod agents with the macrod slug and harness id', async () => {harnessMocks.query.data = [MACROD_HARNESS];+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = successfulModels(+ [{ id: 'claude-code', name: 'Claude Code' }],+ 'claude-code'+ );render(() => <Agents />);fireEvent.click(screen.getByRole('button', { name: 'Create agent' }));@@ -755,7 +940,7 @@ describe('Agents', () => {avatarUrl: undefined,channelIds: [],channelScope: 'all',- defaultModel: 'default',+ defaultModel: 'claude-code',handle: 'bug-fixer',harness: 'macrod',harnessId: MACROD_HARNESS.id,@@ -767,8 +952,46 @@ describe('Agents', () => {});});+ it('preserves and labels a saved model missing from the fresh catalog', () => {+ agentMocks.query.data = [+ {+ bot: {+ id: 'agent-1',+ kind: 'owned',+ owner: { type: 'user', user_id: 'macro|[email protected]' },+ name: 'Bug fixer',+ handle: 'bug-fixer',+ has_agent: true,+ created_at: '2026-08-27T12:00:00Z',+ updated_at: '2026-08-27T12:00:00Z',+ },+ instructions: 'Fix the root cause.',+ harness: 'in-memory',+ default_model: 'retired-model',+ channel_scope: 'all',+ channel_ids: [],+ },+ ];++ render(() => <Agents />);+ fireEvent.click(screen.getByRole('button', { name: 'Edit Bug fixer' }));++ const defaultModel = within(screen.getByRole('dialog')).getByLabelText(+ 'Default model'+ );+ expect(defaultModel).toHaveProperty('value', 'retired-model');+ expect(+ within(defaultModel).getByRole('option', {+ name: 'retired-model (saved, unavailable)',+ })+ ).toBeTruthy();+ });+it('preselects the bound macrod harness when editing', () => {harnessMocks.query.data = [MACROD_HARNESS];+ modelMocks.queries[`macrod:${MACROD_HARNESS.id}`] = successfulModels([+ { id: 'default', name: 'Harness default' },+ ]);agentMocks.query.data = [{bot: {@@ -800,7 +1023,7 @@ describe('Agents', () => {MACROD_HARNESS.id);const defaultModel = within(dialog).getByLabelText('Default model');- expect(defaultModel.tagName).toBe('INPUT');+ expect(defaultModel.tagName).toBe('SELECT');expect(defaultModel).toHaveProperty('value', 'default');});diff --git a/apps/web/src/features/settings/Agents.tsx b/apps/web/src/features/settings/Agents.tsxindex 5e6e0f3190..cb642be515 100644--- a/apps/web/src/features/settings/Agents.tsx+++ b/apps/web/src/features/settings/Agents.tsx@@ -22,9 +22,11 @@ import {useUpdateAgentMutation,} from '@queries/agents/agents';import {- useCursorApiKeyStatusQuery,- useCursorModelsQuery,-} from '@queries/auth/cursor-api-key';+ type AgentModelTarget,+ buildAgentModelTargets,+ useAgentModelsQueries,+} from '@queries/agents/models';+import { useCursorApiKeyStatusQuery } from '@queries/auth/cursor-api-key';import { useHarnessesQuery } from '@queries/harnesses/harnesses';import { usePipedreamConnectedSlugs } from '@queries/pipedream-connectors';import { useCurrentTeamQuery, useIsTeamOwner } from '@queries/team/teams';@@ -63,29 +65,18 @@ type AgentSummary = {type ConnectedHarness = {id: string;name: string;- models: readonly HarnessModel[];- modelsLoading?: boolean;- modelsError?: boolean;kind: 'builtin' | 'macrod';+ target: AgentModelTarget;connected?: boolean;};-type HarnessModel = {- id: string;- name: string;- /** The heading the harness lists this model under, when it groups them. */- group?: string;-};-type ChannelOption = ReturnType<typeof botAssignableChannelOptions>[number];const IN_MEMORY_HARNESS: ConnectedHarness = {id: 'in-memory',name: 'In-memory',- models: [Model.sonnet5, Model.opus5, Model.haiku45, Model.gpt56].map(- (model) => ({ id: model, name: MODEL_PRETTYNAME[model] })- ),kind: 'builtin',+ target: { harness: 'in-memory' },};const MACRO_AGENT: AgentSummary = {@@ -115,38 +106,37 @@ export function Agents() {const cursorStatus = useCursorApiKeyStatusQuery();const cursorConnected = () =>cursorStatus.isSuccess ? cursorStatus.data.registered : false;- const cursorModels = useCursorModelsQuery(cursorConnected);const harnessesQuery = useHarnessesQuery();- const connectedHarnesses = (): readonly ConnectedHarness[] => [- IN_MEMORY_HARNESS,- ...(cursorConnected()- ? [- {+ const connectedHarnesses = (): readonly ConnectedHarness[] => {+ const harnesses = harnessesQuery.isSuccess ? harnessesQuery.data : [];+ return buildAgentModelTargets(cursorConnected(), harnesses).map(+ (target) => {+ if (target.harness === 'in-memory') return IN_MEMORY_HARNESS;+ if (target.harness === 'cursor') {+ return {id: 'cursor',name: 'Cursor',- models: (cursorModels.isSuccess- ? cursorModels.data.models- : []- ).map((model) => ({- id: model.id,- name: model.displayName,- group: model.group,- })),- modelsLoading: cursorModels.isPending,- modelsError: cursorModels.isError,- kind: 'builtin' as const,- },- ]- : []),- ...(harnessesQuery.isSuccess ? harnessesQuery.data : []).map((harness) => ({- id: harness.id,- name:- harness.owner.type === 'team' ? `${harness.name} · Team` : harness.name,- models: [],- kind: 'macrod' as const,- connected: harness.connected,- })),- ];+ kind: 'builtin',+ target,+ };+ }++ const harness = harnesses.find(+ (candidate) => candidate.id === target.harnessId+ );+ return {+ id: target.harnessId ?? '',+ name:+ harness?.owner.type === 'team'+ ? `${harness.name} · Team`+ : (harness?.name ?? 'macrod'),+ kind: 'macrod',+ target,+ connected: harness?.connected,+ };+ }+ );+ };const channelOptions = createMemo(() =>botAssignableChannelOptions(channelsContext.channels()));@@ -347,9 +337,6 @@ function summarizeAgent(): AgentSummary {const harnessKey = agent.harness_id ?? agent.harness;const harness = harnesses.find((option) => option.id === harnessKey);- const model = harness?.models.find(- (option) => option.id === agent.default_model- );const selectedChannelNames = channels.filter((channel) => agent.channel_ids.includes(channel.id)).map((channel) => `#${channel.name}`);@@ -367,7 +354,8 @@ function summarizeAgent(avatarUrl: agent.bot.avatar_url ?? undefined,instructions: agent.instructions,harness: harness?.name ?? harnessName(harnessKey),- defaultModel: model?.name ?? agent.default_model,+ defaultModel:+ MODEL_PRETTYNAME[agent.default_model as Model] ?? agent.default_model,channelSummary,share: agent.bot.owner?.type === 'team' ? 'Team' : 'Private',persistedAgent: agent,@@ -542,20 +530,75 @@ function AgentDialog(props: {props.connectedHarnesses[0]?.id ??'');+ const modelQueries = useAgentModelsQueries(() =>+ props.connectedHarnesses.map((harness) => harness.target)+ );const selectedHarness = () =>props.connectedHarnesses.find((harness) => harness.id === harnessId());+ const modelQueryForHarness = (id: string) => {+ const index = props.connectedHarnesses.findIndex(+ (harness) => harness.id === id+ );+ return index >= 0 ? modelQueries[index] : undefined;+ };+ const modelDataForHarness = (id: string) => {+ const query = modelQueryForHarness(id);+ return query?.isSuccess ? query.data : undefined;+ };+ const preferredModelId = (id: string) => {+ const data = modelDataForHarness(id);+ if (data?.status === 'unsupported') return 'default';+ if (data?.status !== 'available') return '';+ const current = data.currentModel;+ if (+ current &&+ (data.models.length === 0 ||+ data.models.some((model) => model.id === current))+ ) {+ return current;+ }+ return data.models[0]?.id ?? '';+ };const [defaultModelId, setDefaultModelId] = createSignal(props.agent?.default_model ?? '');const selectedDefaultModelId = () =>- defaultModelId() || selectedHarness()?.models[0]?.id || '';+ defaultModelId() || preferredModelId(harnessId());+ const selectedModelQuery = () => modelQueryForHarness(harnessId());+ const selectedModelData = () => modelDataForHarness(harnessId());+ const selectedModelOptions = () => {+ const data = selectedModelData();+ if (data?.status !== 'available') return [];++ const selected = selectedDefaultModelId();+ const savedModel =+ props.agent?.default_model === selected &&+ (props.agent.harness_id ?? props.agent.harness) === harnessId();+ if (+ selected.length === 0 ||+ data.models.some((model) => model.id === selected)+ ) {+ return data.models;+ }+ return [+ ...data.models,+ {+ id: selected,+ name: `${selected} (${savedModel ? 'saved, ' : ''}unavailable)`,+ description: undefined,+ group: undefined,+ },+ ];+ };+ const selectedCatalogOptions = () =>+ selectedModelOptions().map((model) => ({+ id: model.id,+ label: model.name,+ description: model.description ?? undefined,+ group: model.group ?? undefined,+ }));const selectedHarnessUsesCatalog = () =>- isLargeModelCatalog(- (selectedHarness()?.models ?? []).map((model) => ({- id: model.id,- label: model.name,- }))- );+ isLargeModelCatalog(selectedCatalogOptions());const [channelMode, setChannelMode] = createSignal<ChannelMode>(props.agent?.channel_scope ?? 'all');@@ -601,11 +644,7 @@ function AgentDialog(props: {const handleHarnessChange = (id: string) => {setHarnessId(id);- const harness = props.connectedHarnesses.find((option) => option.id === id);- // macrod treats 'default' as "use the harness's own configured model".- setDefaultModelId(- harness?.kind === 'macrod' ? 'default' : (harness?.models[0]?.id ?? '')- );+ setDefaultModelId(preferredModelId(id));};const handleAvatarInput = (file: File | undefined) => {@@ -817,71 +856,100 @@ function AgentDialog(props: {Default model</span><Show- when={selectedHarness()?.kind === 'macrod'}+ when={selectedModelQuery()}fallback={+ <p class="settings-input text-ink-muted">+ Model discovery unavailable+ </p>+ }+ keyed+ >+ {(query) => (<Show- when={selectedHarnessUsesCatalog()}+ when={!query.isPending}fallback={<select- class="settings-input w-full"- value={selectedDefaultModelId()}aria-label="Default model"- disabled={- selectedHarness()?.modelsLoading ||- selectedHarness()?.modelsError- }- onChange={(event) =>- setDefaultModelId(event.currentTarget.value)- }+ class="settings-input w-full"+ disabled>- <For each={selectedHarness()?.models ?? []}>- {(model) => (- <option- value={model.id}- selected={- model.id === selectedDefaultModelId()- }- >- {model.name}- </option>- )}- </For>+ <option>Loading models…</option></select>}>- <ModelCatalogPicker- value={selectedDefaultModelId()}- options={(selectedHarness()?.models ?? []).map(- (model) => ({- id: model.id,- label: model.name,- group: model.group,- })- )}- onSelect={setDefaultModelId}- ariaLabel="Default model"- triggerClass="w-full justify-between"- contentClass="overflow-hidden"- />+ <Show+ when={!query.isError}+ fallback={+ <div class="flex items-center gap-2">+ <p class="min-w-0 flex-1 text-xs text-negative">+ Could not load models for{' '}+ {selectedHarness()?.name ?? 'this harness'}.+ </p>+ <Button+ type="button"+ variant="outline"+ size="sm"+ aria-label={`Retry models for ${selectedHarness()?.name ?? 'this harness'}`}+ onClick={() => void query.refetch()}+ >+ Retry+ </Button>+ </div>+ }+ >+ <Show+ when={selectedModelData()?.status === 'available'}+ fallback={+ <p class="settings-input text-ink-muted">+ Model selection is unsupported by this harness.+ </p>+ }+ >+ <Show+ when={selectedModelOptions().length > 0}+ fallback={+ <p class="settings-input text-ink-muted">+ This harness did not return any models.+ </p>+ }+ >+ <Show+ when={selectedHarnessUsesCatalog()}+ fallback={+ <select+ aria-label="Default model"+ class="settings-input w-full"+ value={selectedDefaultModelId()}+ onChange={(event) =>+ setDefaultModelId(+ event.currentTarget.value+ )+ }+ >+ <For each={selectedModelOptions()}>+ {(model) => (+ <option value={model.id}>+ {model.name}+ </option>+ )}+ </For>+ </select>+ }+ >+ <ModelCatalogPicker+ value={selectedDefaultModelId()}+ options={selectedCatalogOptions()}+ onSelect={setDefaultModelId}+ ariaLabel="Default model"+ triggerClass="w-full justify-between"+ contentClass="overflow-hidden"+ />+ </Show>+ </Show>+ </Show>+ </Show></Show>- }- >- <input- class="settings-input w-full"- placeholder="default"- value={defaultModelId()}- onInput={(event) =>- setDefaultModelId(event.currentTarget.value)- }- />- </Show>- <Show when={selectedHarness()?.modelsLoading}>- <span class="text-xs text-ink-muted">Loading models…</span>- </Show>- <Show when={selectedHarness()?.modelsError}>- <span class="text-xs text-negative">- Could not load Cursor models. Try refreshing this page.- </span>+ )}</Show></label></div>diff --git a/apps/web/src/features/settings/Harness.test.tsx b/apps/web/src/features/settings/Harness.test.tsxindex a7212985ad..4fbd6d08f2 100644--- a/apps/web/src/features/settings/Harness.test.tsx+++ b/apps/web/src/features/settings/Harness.test.tsx@@ -2,8 +2,8 @@* @vitest-environment jsdom*/-import { useCursorModelsQuery } from '@queries/auth/cursor-api-key';-import type { CursorModelsResponse } from '@service-auth/generated/schemas';+import { useAgentModelsQuery } from '@queries/agents/models';+import type { LoadAgentModelsResponse } from '@service-agent-harness/generated/schemas';import {fireEvent,render,@@ -32,12 +32,15 @@ const mocks = vi.hoisted(() => ({isPlaceholderData: false,},models: {- isSuccess: true,- isPending: false,- isError: false,data: {- models: [{ id: 'default-model', displayName: 'Default Model' }],+ status: 'available' as const,+ currentModel: 'default-model',+ models: [{ id: 'default-model', name: 'Default Model' }],},+ isPending: false,+ isError: false,+ isSuccess: true,+ refetch: vi.fn(),},save: vi.fn(),disconnect: vi.fn(),@@ -80,13 +83,16 @@ vi.mock('@queries/auth/cursor-api-key', () => ({mutateAsync: mocks.disconnect,isPending: false,}),- useCursorModelsQuery: vi.fn(() => mocks.models),useSetCursorDefaultModel: () => ({mutateAsync: mocks.setDefaultModel,isPending: false,}),}));+vi.mock('@queries/agents/models', () => ({+ useAgentModelsQuery: vi.fn(() => mocks.models),+}));+vi.mock('@queries/harnesses/harnesses', () => ({useHarnessesQuery: () => harnessMocks.query,useDeleteHarnessMutation: () => ({@@ -102,6 +108,9 @@ vi.mock('@queries/harnesses/harnesses', () => ({get isError() {return Boolean(code()) && harnessMocks.pairing.isError;},+ get isSuccess() {+ return Boolean(code()) && !harnessMocks.pairing.isError;+ },get error() {return harnessMocks.pairing.isError ? new Error('gone') : null;},@@ -155,6 +164,14 @@ beforeEach(() => {updatedAt: null,};mocks.status.isPlaceholderData = false;+ mocks.models.data = {+ status: 'available',+ currentModel: 'default-model',+ models: [{ id: 'default-model', name: 'Default Model' }],+ };+ mocks.models.isPending = false;+ mocks.models.isError = false;+ mocks.models.isSuccess = true;mocks.save.mockResolvedValue(undefined);mocks.disconnect.mockResolvedValue(undefined);harnessMocks.query.data = [];@@ -170,16 +187,18 @@ describe('Harness', () => {'keeps settings visible while Cursor models load and after %s',async (outcome) => {mocks.status.data.registered = true;- let resolveModels!: (models: CursorModelsResponse) => void;+ let resolveModels!: (models: LoadAgentModelsResponse) => void;let rejectModels!: (error: Error) => void;- const response = new Promise<CursorModelsResponse>((resolve, reject) => {- resolveModels = resolve;- rejectModels = reject;- });+ const response = new Promise<LoadAgentModelsResponse>(+ (resolve, reject) => {+ resolveModels = resolve;+ rejectModels = reject;+ }+ );const client = new QueryClient({defaultOptions: { queries: { retry: false } },});- vi.mocked(useCursorModelsQuery).mockImplementationOnce(() =>+ vi.mocked(useAgentModelsQuery).mockImplementationOnce(() =>useQuery(() => ({queryKey: ['pending-cursor-models'],queryFn: () => response,@@ -208,19 +227,15 @@ describe('Harness', () => {expect(screen.getByText(/Could not load Cursor models/)).toBeTruthy());expect(screen.queryByText('Settings suspended')).toBeNull();- expect(- (- screen.getByRole('combobox', {- name: 'Default model',- }) as HTMLSelectElement- ).disabled- ).toBe(true);+ expect(screen.getByRole('button', { name: 'Retry' })).toBeTruthy();} else {resolveModels({+ status: 'available',+ currentModel: 'loaded-model',models: [{id: 'loaded-model',- displayName: 'Loaded Model',+ name: 'Loaded Model',group: 'Cursor',},],diff --git a/apps/web/src/features/settings/Harness.tsx b/apps/web/src/features/settings/Harness.tsxindex b1274c4347..7420c5758f 100644--- a/apps/web/src/features/settings/Harness.tsx+++ b/apps/web/src/features/settings/Harness.tsx@@ -6,9 +6,9 @@ import CursorIcon from '@icon/wide-cursor-ide.svg';import ArrowUpRightIcon from '@phosphor/arrow-up-right.svg';import HardDrivesIcon from '@phosphor/hard-drives.svg';import TerminalWindowIcon from '@phosphor/terminal-window.svg';+import { useAgentModelsQuery } from '@queries/agents/models';import {useCursorApiKeyStatusQuery,- useCursorModelsQuery,useDisconnectCursorApiKey,useSaveCursorApiKey,useSetCursorDefaultModel,@@ -76,14 +76,36 @@ export function Harness() {}};- // Only worth fetching once there is a key to ask Cursor through.- const cursorModels = useCursorModelsQuery(cursorRegistered);+ const cursorModels = useAgentModelsQuery(+ () => ({ harness: 'cursor' }),+ cursorRegistered+ );+ const cursorModelData = () =>+ cursorModels.isSuccess ? cursorModels.data : undefined;+ const cursorModelOptions = () => {+ const data = cursorModelData();+ if (data?.status !== 'available') return [];+ const saved = cursorStatus.data?.defaultModelId;+ if (!saved || data.models.some((model) => model.id === saved)) {+ return data.models;+ }+ return [+ ...data.models,+ {+ id: saved,+ name: `${saved} (saved, unavailable)`,+ description: undefined,+ group: undefined,+ },+ ];+ };const setCursorDefaultModel = useSetCursorDefaultModel();- const cursorModelOptions = () =>- (cursorModels.isSuccess ? cursorModels.data.models : []).map((model) => ({+ const cursorCatalogOptions = () =>+ cursorModelOptions().map((model) => ({id: model.id,- label: model.displayName,- group: model.group,+ label: model.name,+ description: model.description ?? undefined,+ group: model.group ?? undefined,}));const selectedCursorModelId = () =>(cursorStatus.isSuccess ? cursorStatus.data.defaultModelId : null) ??@@ -233,49 +255,81 @@ export function Harness() {Default model</label><Show- when={isLargeModelCatalog(cursorModelOptions())}+ when={!cursorModels.isPending}fallback={<selectid="cursor-default-model"class="settings-input w-56"- value={selectedCursorModelId() ?? ''}- disabled={- setCursorDefaultModel.isPending ||- !cursorModels.isSuccess- }- onChange={(event) =>- void handleCursorModelChange(- event.currentTarget.value- )- }+ disabled>- <For each={cursorModelOptions()}>- {(model) => (- <option value={model.id}>{model.label}</option>- )}- </For>+ <option>Loading models…</option></select>}>- <ModelCatalogPicker- value={selectedCursorModelId()}- options={cursorModelOptions()}- onSelect={(id) => void handleCursorModelChange(id)}- disabled={- setCursorDefaultModel.isPending ||- !cursorModels.isSuccess+ <Show+ when={!cursorModels.isError}+ fallback={+ <div class="flex items-center gap-2">+ <p class="text-xs text-negative">+ Could not load Cursor models.+ </p>+ <Button+ type="button"+ variant="outline"+ size="sm"+ onClick={() => void cursorModels.refetch()}+ >+ Retry+ </Button>+ </div>}- ariaLabel="Default model"- triggerClass="w-72 max-w-full justify-between"- />- </Show>- <Show when={cursorModels.isPending}>- <p class="text-xs text-ink-muted">Loading models…</p>- </Show>- <Show when={cursorModels.isError}>- <p class="text-xs text-negative">- Could not load Cursor models. Try refreshing this page.- </p>+ >+ <Show+ when={cursorModelData()?.status === 'available'}+ fallback={+ <p class="text-xs text-ink-muted">+ Cursor does not support model selection.+ </p>+ }+ >+ <Show+ when={isLargeModelCatalog(cursorCatalogOptions())}+ fallback={+ <select+ id="cursor-default-model"+ class="settings-input w-56"+ value={+ cursorStatus.data?.defaultModelId ??+ cursorModelData()?.currentModel ??+ cursorModelOptions()[0]?.id ??+ ''+ }+ disabled={setCursorDefaultModel.isPending}+ onChange={(event) =>+ void handleCursorModelChange(+ event.currentTarget.value+ )+ }+ >+ <For each={cursorModelOptions()}>+ {(model) => (+ <option value={model.id}>{model.name}</option>+ )}+ </For>+ </select>+ }+ >+ <ModelCatalogPicker+ value={selectedCursorModelId()}+ options={cursorCatalogOptions()}+ onSelect={(id) => void handleCursorModelChange(id)}+ disabled={setCursorDefaultModel.isPending}+ ariaLabel="Default model"+ triggerClass="w-72 max-w-full justify-between"+ />+ </Show>+ </Show>+ </Show></Show><p class="text-xs text-ink-extra-muted">The model new `@cursor` sessions start on. Recommendeddiff --git a/apps/web/src/features/settings/HarnessPairingDialog.test.tsx b/apps/web/src/features/settings/HarnessPairingDialog.test.tsxindex 5f529ac3d3..e8912bd8b2 100644--- a/apps/web/src/features/settings/HarnessPairingDialog.test.tsx+++ b/apps/web/src/features/settings/HarnessPairingDialog.test.tsx@@ -38,6 +38,9 @@ vi.mock('@queries/harnesses/harnesses', () => ({get isError() {return Boolean(code()) && mocks.pairing.isError;},+ get isSuccess() {+ return Boolean(code()) && !mocks.pairing.isError;+ },get error() {return mocks.pairing.isError ? new Error('gone') : null;},diff --git a/apps/web/src/features/settings/HarnessPairingDialog.tsx b/apps/web/src/features/settings/HarnessPairingDialog.tsxindex 461c3d1e1f..9b332a7bc8 100644--- a/apps/web/src/features/settings/HarnessPairingDialog.tsx+++ b/apps/web/src/features/settings/HarnessPairingDialog.tsx@@ -50,9 +50,11 @@ export function HarnessPairingDialog(props: {const currentTeamQuery = useCurrentTeamQuery();const currentTeamId = () => currentTeamQuery.data?.team.id;const canShareWithTeam = () => currentTeamId() !== undefined;+ const pairingData = () =>+ pairingQuery.isSuccess ? pairingQuery.data : undefined;createEffect(() => {- const pairing = pairingQuery.data;+ const pairing = pairingData();if (!pairing) return;if (!nameEdited()) setName(pairing.requested_name);// The daemon's config may ask for a scope; preselect it, but the person@@ -94,7 +96,7 @@ export function HarnessPairingDialog(props: {(share() === 'Private' || canShareWithTeam());const approve = async () => {- const pairing = pairingQuery.data;+ const pairing = pairingData();if (!pairing || !canApprove()) return;setApproveError(undefined);@@ -121,13 +123,13 @@ export function HarnessPairingDialog(props: {visibleScrimclass="w-[min(480px,calc(100vw-16px))]">- <Panel depth={2} class="rounded-xl text-ink">+ <Panel depth={2} class="max-h-[88vh] rounded-xl text-ink"><Panel.Header class="px-5 py-3"><Dialog.Title class="text-sm font-semibold">{approved() ? 'Harness connected' : 'Connect a harness'}</Dialog.Title></Panel.Header>- <Panel.Body class="p-5">+ <Panel.Body class="overflow-y-auto p-5"><Switch><Match when={approved()}><p class="text-sm leading-5 text-ink-muted">@@ -153,7 +155,7 @@ export function HarnessPairingDialog(props: {)}</Match>- <Match when={pairingQuery.data}>+ <Match when={pairingData()}>{(pairing) => (<div class="flex flex-col gap-4"><div class="flex flex-col gap-1.5">@@ -287,7 +289,7 @@ export function HarnessPairingDialog(props: {Close</Button></Match>- <Match when={pairingQuery.data}>+ <Match when={pairingData()}><Buttontype="button"variant="ghost"diff --git a/apps/web/src/lib/queries/agents/models.test.tsx b/apps/web/src/lib/queries/agents/models.test.tsxnew file mode 100644index 0000000000..cd2e086abc--- /dev/null+++ b/apps/web/src/lib/queries/agents/models.test.tsx@@ -0,0 +1,84 @@+/**+ * @vitest-environment jsdom+ */++import { agentHarnessServiceClient } from '@service-agent-harness/client';+import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';+import type { JSX } from 'solid-js';+import { render } from 'solid-js/web';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { buildAgentModelTargets, useAgentModelsQueries } from './models';++vi.mock('@service-agent-harness/client', () => ({+ agentHarnessServiceClient: {+ loadAgentModels: vi.fn(),+ },+}));++let queryClient: QueryClient;+let dispose: (() => void) | undefined;++function renderHook(factory: () => unknown) {+ dispose = render(+ () => (+ <QueryClientProvider client={queryClient}>+ {(() => {+ factory();+ return null as unknown as JSX.Element;+ })()}+ </QueryClientProvider>+ ),+ document.body+ );+}++beforeEach(() => {+ vi.clearAllMocks();+ queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });+});++afterEach(() => {+ dispose?.();+ dispose = undefined;+ queryClient.clear();+});++describe('agent model discovery', () => {+ it('constructs every available target in parallel without waiting for another target', async () => {+ const targets = buildAgentModelTargets(true, [+ { id: 'harness-a' },+ { id: 'harness-b' },+ ]);+ const pending = new Promise<never>(() => {});+ vi.mocked(agentHarnessServiceClient.loadAgentModels).mockReturnValue(+ pending+ );++ renderHook(() => useAgentModelsQueries(() => targets));++ await vi.waitFor(() => {+ expect(agentHarnessServiceClient.loadAgentModels).toHaveBeenCalledTimes(+ 4+ );+ });+ expect(+ vi+ .mocked(agentHarnessServiceClient.loadAgentModels)+ .mock.calls.map(([request]) => request)+ ).toEqual([+ { harness: 'in-memory' },+ { harness: 'cursor' },+ { harness: 'macrod', harnessId: 'harness-a' },+ { harness: 'macrod', harnessId: 'harness-b' },+ ]);+ });++ it('omits Cursor when it is not registered', () => {+ expect(buildAgentModelTargets(false, [{ id: 'harness-a' }])).toEqual([+ { harness: 'in-memory' },+ { harness: 'macrod', harnessId: 'harness-a' },+ ]);+ });+});diff --git a/apps/web/src/lib/queries/agents/models.ts b/apps/web/src/lib/queries/agents/models.tsnew file mode 100644index 0000000000..ca980c8401--- /dev/null+++ b/apps/web/src/lib/queries/agents/models.ts@@ -0,0 +1,70 @@+import { throwOnErr } from '@core/util/result';+import { agentHarnessServiceClient } from '@service-agent-harness/client';+import type {+ LoadAgentModelsRequest,+ LoadAgentModelsResponse,+} from '@service-agent-harness/generated/schemas';+import type { Harness } from '@service-storage/client';+import { useQueries, useQuery } from '@tanstack/solid-query';++export type AgentModelTarget = LoadAgentModelsRequest;++/** Every model provider available to the agent dialog, in display order. */+export function buildAgentModelTargets(+ cursorRegistered: boolean,+ harnesses: readonly Pick<Harness, 'id'>[]+): AgentModelTarget[] {+ const targets: AgentModelTarget[] = [{ harness: 'in-memory' }];+ if (cursorRegistered) targets.push({ harness: 'cursor' });+ targets.push(+ ...harnesses.map(+ (harness): AgentModelTarget => ({+ harness: 'macrod',+ harnessId: harness.id,+ })+ )+ );+ return targets;+}++export function agentModelsQueryOptions(target: AgentModelTarget) {+ return {+ queryKey: [+ 'agent-models',+ 'load',+ target.harness,+ target.harnessId ?? null,+ ] as const,+ queryFn: async ({+ signal,+ }: {+ signal: AbortSignal;+ }): Promise<LoadAgentModelsResponse> =>+ await throwOnErr(() =>+ agentHarnessServiceClient.loadAgentModels(target, signal)+ ),+ gcTime: 0,+ staleTime: 0,+ retry: false,+ };+}++/** Launches one independent, fresh model-discovery request per target. */+export function useAgentModelsQueries(+ targets: () => readonly AgentModelTarget[]+) {+ return useQueries(() => ({+ queries: targets().map(agentModelsQueryOptions),+ }));+}++/** Loads one provider's current model catalog. */+export function useAgentModelsQuery(+ target: () => AgentModelTarget,+ enabled: () => boolean = () => true+) {+ return useQuery(() => ({+ ...agentModelsQueryOptions(target()),+ enabled: enabled(),+ }));+}diff --git a/apps/web/src/lib/service-clients/service-agent-harness/client.ts b/apps/web/src/lib/service-clients/service-agent-harness/client.tsindex 81ed632377..3cf0c135f4 100644--- a/apps/web/src/lib/service-clients/service-agent-harness/client.ts+++ b/apps/web/src/lib/service-clients/service-agent-harness/client.ts@@ -8,6 +8,8 @@ import type {ControlResponse,CreateAgentSessionRequest,CreateAgentSessionResponse,+ LoadAgentModelsRequest,+ LoadAgentModelsResponse,SandboxSize,SandboxSizeBody,} from './generated/schemas';@@ -18,6 +20,19 @@ const agentHarnessHost = SERVER_HOSTS['agent-harness'];/** Authenticated client for controlling live agent sessions. */export const agentHarnessServiceClient = {+ /** Probes one agent target for its current, uncached model catalog. */+ loadAgentModels(request: LoadAgentModelsRequest, signal?: AbortSignal) {+ return fetchWithToken<LoadAgentModelsResponse>(+ `${agentHarnessHost}/agent-models/load`,+ {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(request),+ signal,+ }+ );+ },+create(request: CreateAgentSessionRequest) {return fetchWithToken<CreateAgentSessionResponse>(`${agentHarnessHost}/agent-sessions`,diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/client.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/client.tsindex fa8a5d09f9..7c5170abf7 100644--- a/apps/web/src/lib/service-clients/service-agent-harness/generated/client.ts+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/client.ts@@ -13,10 +13,96 @@ import type {CreateAgentSessionRequest,CreateAgentSessionResponse,EditQueuedActionRequest,+ LoadAgentModelsRequest,+ LoadAgentModelsResponse,RenameAgentSessionRequest,SandboxSizeBody,} from './schemas';+/**+ * @summary Probe one provider's model catalog without creating an agent session.+ */+export type loadAgentModelsHandlerResponse200 = {+ data: LoadAgentModelsResponse;+ status: 200;+};++export type loadAgentModelsHandlerResponse400 = {+ data: void;+ status: 400;+};++export type loadAgentModelsHandlerResponse401 = {+ data: void;+ status: 401;+};++export type loadAgentModelsHandlerResponse403 = {+ data: void;+ status: 403;+};++export type loadAgentModelsHandlerResponse409 = {+ data: void;+ status: 409;+};++export type loadAgentModelsHandlerResponse502 = {+ data: void;+ status: 502;+};++export type loadAgentModelsHandlerResponse504 = {+ data: void;+ status: 504;+};++export type loadAgentModelsHandlerResponseSuccess =+ loadAgentModelsHandlerResponse200 & {+ headers: Headers;+ };+export type loadAgentModelsHandlerResponseError = (+ | loadAgentModelsHandlerResponse400+ | loadAgentModelsHandlerResponse401+ | loadAgentModelsHandlerResponse403+ | loadAgentModelsHandlerResponse409+ | loadAgentModelsHandlerResponse502+ | loadAgentModelsHandlerResponse504+) & {+ headers: Headers;+};++export type loadAgentModelsHandlerResponse =+ | loadAgentModelsHandlerResponseSuccess+ | loadAgentModelsHandlerResponseError;++export const getLoadAgentModelsHandlerUrl = () => {+ return `/agent-models/load`;+};++export const loadAgentModelsHandler = async (+ loadAgentModelsRequest: LoadAgentModelsRequest,+ options?: RequestInit+): Promise<loadAgentModelsHandlerResponse> => {+ const res = await fetch(getLoadAgentModelsHandlerUrl(), {+ ...options,+ method: 'POST',+ headers: { 'Content-Type': 'application/json', ...options?.headers },+ body: JSON.stringify(loadAgentModelsRequest),+ });++ const body = [204, 205, 304].includes(res.status) ? null : await res.text();++ const data: loadAgentModelsHandlerResponse['data'] = body+ ? JSON.parse(body)+ : {};+ return {+ data,+ status: res.status,+ headers: res.headers,+ } as loadAgentModelsHandlerResponse;+};+/*** @summary Read the caller's default sandbox size for new `@coder` sessions.*/diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDto.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDto.tsnew file mode 100644index 0000000000..9058d5fe5b--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDto.ts@@ -0,0 +1,22 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */+import type { AgentModelDtoDescription } from './agentModelDtoDescription';+import type { AgentModelDtoGroup } from './agentModelDtoGroup';++/**+ * One model picker option.+ */+export interface AgentModelDto {+ /** Optional provider description. */+ description?: AgentModelDtoDescription;+ /** Optional group heading supplied by the provider. */+ group?: AgentModelDtoGroup;+ /** Provider model id. */+ id: string;+ /** Display name. */+ name: string;+}diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoDescription.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoDescription.tsnew file mode 100644index 0000000000..17282db4d8--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoDescription.ts@@ -0,0 +1,11 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Optional provider description.+ */+export type AgentModelDtoDescription = string | null;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoGroup.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoGroup.tsnew file mode 100644index 0000000000..574b0d6f90--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelDtoGroup.ts@@ -0,0 +1,11 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Optional group heading supplied by the provider.+ */+export type AgentModelDtoGroup = string | null;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelsStatusDto.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelsStatusDto.tsnew file mode 100644index 0000000000..ff33dae933--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/agentModelsStatusDto.ts@@ -0,0 +1,18 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Model-selection availability returned over HTTP.+ */+export type AgentModelsStatusDto =+ (typeof AgentModelsStatusDto)[keyof typeof AgentModelsStatusDto];++// eslint-disable-next-line @typescript-eslint/no-redeclare+export const AgentModelsStatusDto = {+ available: 'available',+ unsupported: 'unsupported',+} as const;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/index.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/index.tsindex 31444fdfb1..292789fc77 100644--- a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/index.ts+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/index.ts@@ -20,6 +20,10 @@ export * from './agentActionOneOfOneoneAllOf';export * from './agentActionOneOfOneoneAllOfType';export * from './agentActionOneOfSeven';export * from './agentActionOneOfSevenType';+export * from './agentModelDto';+export * from './agentModelDtoDescription';+export * from './agentModelDtoGroup';+export * from './agentModelsStatusDto';export * from './agentPromptAction';export * from './agentRespondElicitationAction';export * from './agentRespondElicitationActionAllOf';@@ -67,9 +71,14 @@ export * from './elicitationRequestId';export * from './externalSessionResponse';export * from './externalSessionResponseName';export * from './externalSessionResponseUrl';+export * from './loadAgentModelsRequest';+export * from './loadAgentModelsRequestHarnessId';+export * from './loadAgentModelsResponse';+export * from './loadAgentModelsResponseCurrentModel';export * from './logDirectionDto';export * from './logFrameDto';export * from './logFrameDtoContent';+export * from './modelHarnessDto';export * from './queuedActionDto';export * from './queuedActionDtoActorUserId';export * from './queuedActionDtoPrompt';diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequest.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequest.tsnew file mode 100644index 0000000000..109b3135f0--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequest.ts@@ -0,0 +1,19 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++import type { LoadAgentModelsRequestHarnessId } from './loadAgentModelsRequestHarnessId';+import type { ModelHarnessDto } from './modelHarnessDto';++/**+ * HTTP request selecting one provider to probe.+ */+export interface LoadAgentModelsRequest {+ /** Provider to probe. */+ harness: ModelHarnessDto;+ /** Required for macrod and forbidden for other targets. */+ harnessId?: LoadAgentModelsRequestHarnessId;+}diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequestHarnessId.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequestHarnessId.tsnew file mode 100644index 0000000000..43a300ebae--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsRequestHarnessId.ts@@ -0,0 +1,11 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Required for macrod and forbidden for other targets.+ */+export type LoadAgentModelsRequestHarnessId = string | null;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponse.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponse.tsnew file mode 100644index 0000000000..ecde35eab7--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponse.ts@@ -0,0 +1,22 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++import type { AgentModelDto } from './agentModelDto';+import type { AgentModelsStatusDto } from './agentModelsStatusDto';+import type { LoadAgentModelsResponseCurrentModel } from './loadAgentModelsResponseCurrentModel';++/**+ * Successful model-discovery response.+ */+export interface LoadAgentModelsResponse {+ /** Current provider model, if model selection is available. */+ currentModel?: LoadAgentModelsResponseCurrentModel;+ /** Ordered model catalog. */+ models: AgentModelDto[];+ /** Model-selection availability. */+ status: AgentModelsStatusDto;+}diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponseCurrentModel.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponseCurrentModel.tsnew file mode 100644index 0000000000..4cf32f8fb9--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/loadAgentModelsResponseCurrentModel.ts@@ -0,0 +1,11 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Current provider model, if model selection is available.+ */+export type LoadAgentModelsResponseCurrentModel = string | null;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/modelHarnessDto.ts b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/modelHarnessDto.tsnew file mode 100644index 0000000000..15d05b1db3--- /dev/null+++ b/apps/web/src/lib/service-clients/service-agent-harness/generated/schemas/modelHarnessDto.ts@@ -0,0 +1,19 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * agent_harness_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Harness names accepted by the model discovery endpoint.+ */+export type ModelHarnessDto =+ (typeof ModelHarnessDto)[keyof typeof ModelHarnessDto];++// eslint-disable-next-line @typescript-eslint/no-redeclare+export const ModelHarnessDto = {+ 'in-memory': 'in-memory',+ cursor: 'cursor',+ macrod: 'macrod',+} as const;diff --git a/apps/web/src/lib/service-clients/service-agent-harness/openapi.json b/apps/web/src/lib/service-clients/service-agent-harness/openapi.jsonindex 9b337e6f15..9f079d8c48 100644--- a/apps/web/src/lib/service-clients/service-agent-harness/openapi.json+++ b/apps/web/src/lib/service-clients/service-agent-harness/openapi.json@@ -10,6 +10,58 @@"version": "0.1.0"},"paths": {+ "/agent-models/load": {+ "post": {+ "tags": ["agent-models"],+ "summary": "Probe one provider's model catalog without creating an agent session.",+ "operationId": "load_agent_models_handler",+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/LoadAgentModelsRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "Fresh provider model catalog",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/LoadAgentModelsResponse"+ }+ }+ }+ },+ "400": {+ "description": "Invalid target"+ },+ "401": {+ "description": "Unauthenticated"+ },+ "403": {+ "description": "Harness is not visible to caller"+ },+ "409": {+ "description": "Macrod runtime is disconnected"+ },+ "502": {+ "description": "Provider probe failed"+ },+ "504": {+ "description": "Macrod probe timed out"+ }+ },+ "security": [+ {+ "bearerAuth": []+ }+ ]+ }+ },"/agent-sandbox-size": {"get": {"tags": ["agent-sessions"],@@ -897,6 +949,34 @@"format": "uuid","description": "Identifies one accepted [`AgentAction`] end to end: returned by the\ncontrol endpoint, written as the JSON-RPC request id on the action's wire\nframe, and read back off that frame as `request_id` on the folded message\nit derives.\n\nMinted only by the server at accept time, as a v7 uuid so ids sort by mint\ntime. On the wire and in JSON it is the bare uuid, and a uuid-shaped\nrequest id is the whole ownership test: the server is the only writer of\nruntime-bound frames. The machine's own handshake request ids\n(`agent_session:{session}:{n}`) are not uuids and stay `None`."},+ "AgentModelDto": {+ "type": "object",+ "description": "One model picker option.",+ "required": ["id", "name"],+ "properties": {+ "description": {+ "type": ["string", "null"],+ "description": "Optional provider description."+ },+ "group": {+ "type": ["string", "null"],+ "description": "Optional group heading supplied by the provider."+ },+ "id": {+ "type": "string",+ "description": "Provider model id."+ },+ "name": {+ "type": "string",+ "description": "Display name."+ }+ }+ },+ "AgentModelsStatusDto": {+ "type": "string",+ "description": "Model-selection availability returned over HTTP.",+ "enum": ["available", "unsupported"]+ },"AgentPromptAction": {"type": "object","description": "Ask the agent to work on something.",@@ -1338,6 +1418,44 @@}}},+ "LoadAgentModelsRequest": {+ "type": "object",+ "description": "HTTP request selecting one provider to probe.",+ "required": ["harness"],+ "properties": {+ "harness": {+ "$ref": "#/components/schemas/ModelHarnessDto",+ "description": "Provider to probe."+ },+ "harnessId": {+ "type": ["string", "null"],+ "format": "uuid",+ "description": "Required for macrod and forbidden for other targets."+ }+ }+ },+ "LoadAgentModelsResponse": {+ "type": "object",+ "description": "Successful model-discovery response.",+ "required": ["status", "models"],+ "properties": {+ "currentModel": {+ "type": ["string", "null"],+ "description": "Current provider model, if model selection is available."+ },+ "models": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/AgentModelDto"+ },+ "description": "Ordered model catalog."+ },+ "status": {+ "$ref": "#/components/schemas/AgentModelsStatusDto",+ "description": "Model-selection availability."+ }+ }+ },"LogDirectionDto": {"type": "string","description": "Which way a logged frame travelled, mirroring [`Message`]'s discriminant.",@@ -1358,6 +1476,11 @@}}},+ "ModelHarnessDto": {+ "type": "string",+ "description": "Harness names accepted by the model discovery endpoint.",+ "enum": ["in-memory", "cursor", "macrod"]+ },"QueuedActionDto": {"type": "object","description": "One action waiting in a session's queue.\n\nClients deserialize this, so both derives are used.",@@ -1474,12 +1597,22 @@],"description": "Transport representation of a session's status, mirroring\n[`SessionStatus`]."}+ },+ "securitySchemes": {+ "bearerAuth": {+ "type": "http",+ "scheme": "bearer"+ }}},"tags": [{"name": "agent-sessions","description": "Agent sessions"+ },+ {+ "name": "agent-models",+ "description": "Fresh provider model discovery"}]}diff --git a/apps/web/src/lib/service-clients/service-storage/client.ts b/apps/web/src/lib/service-clients/service-storage/client.tsindex fbb92062e2..a4a07f9783 100644--- a/apps/web/src/lib/service-clients/service-storage/client.ts+++ b/apps/web/src/lib/service-clients/service-storage/client.ts@@ -130,6 +130,7 @@ import type { ListOccurrencesParams } from './generated/schemas/listOccurrencesPimport type { ListRemindersParams } from './generated/schemas/listRemindersParams';import type { ListTeamOutOfOfficeParams } from './generated/schemas/listTeamOutOfOfficeParams';import type { LocationResponseV3 } from './generated/schemas/locationResponseV3';+import type { PairingDetails } from './generated/schemas/pairingDetails';import type { PatchChannelRequest } from './generated/schemas/patchChannelRequest';import type { PatchMessageRequest } from './generated/schemas/patchMessageRequest';import type { PinRequest } from './generated/schemas/pinRequest';@@ -308,15 +309,7 @@ export type Harness = {};/** A pending macrod pairing request, looked up by its printed code. */-export type HarnessPairing = {- code: string;- requested_name: string;- host: string | null;- /** The scope the daemon's config asked for; preselects the dialog. */- requested_scope: 'private' | 'team' | null;- created_at: string;- expires_at: string;-};+export type HarnessPairing = PairingDetails;type ApproveHarnessPairingRequest = {name?: string;diff --git a/crates/agent_fold/src/domain/fold/config.rs b/crates/agent_fold/src/domain/fold/config.rsindex 7d1383b664..2872a4636d 100644--- a/crates/agent_fold/src/domain/fold/config.rs+++ b/crates/agent_fold/src/domain/fold/config.rs@@ -1,16 +1,15 @@//! Config options, available commands, and session info: the metadata.use crate::domain::harness::ToolFrame;-use crate::domain::model::{AvailableCommand, Harness, ModelOption};+use crate::domain::model::{AvailableCommand, Harness};+use crate::domain::model_selection::model_selection;use agent_client_protocol::schema::MaybeUndefined;use agent_client_protocol::schema::v1::{AvailableCommandInput, AvailableCommandsUpdate as AcpAvailableCommandsUpdate,InitializeRequest, InitializeResponse, LoadSessionRequest, NewSessionRequest,- ResumeSessionRequest, SessionConfigKind, SessionConfigOption, SessionConfigSelectOption,- SessionConfigSelectOptions, SessionInfoUpdate, SetSessionConfigOptionRequest,+ ResumeSessionRequest, SessionConfigOption, SessionInfoUpdate, SetSessionConfigOptionRequest,};use agent_client_protocol::{JsonRpcMessage, RawJsonRpcMessage};-use agent_runtime_protocol::domain::action::MODEL_CONFIG_ID;use serde::Deserialize;use super::state::FoldState;@@ -92,45 +91,15 @@ impl FoldState {/// Update the metadata's model fields from a fresh config-options list.pub(super) fn apply_config_options(&mut self, options: Vec<SessionConfigOption>) -> bool {- let model = options- .into_iter()- .find(|option| option.id.to_string() == MODEL_CONFIG_ID);- let Some(SessionConfigOption {- kind: SessionConfigKind::Select(select),- ..- }) = model- else {+ let Some(selection) = model_selection(&options) else {return false;};- let model = Some(select.current_value.to_string());- let to_option = |option: SessionConfigSelectOption, group: Option<&str>| ModelOption {- id: option.value.to_string(),- name: option.name,- description: option.description,- group: group.map(str::to_owned),- };- let supported: Vec<ModelOption> = match select.options {- SessionConfigSelectOptions::Ungrouped(options) => options- .into_iter()- .map(|option| to_option(option, None))- .collect(),- SessionConfigSelectOptions::Grouped(groups) => groups- .into_iter()- .flat_map(|group| {- let name = group.name;- group- .options- .into_iter()- .map(move |option| to_option(option, Some(&name)))- })- .collect(),- _ => return false,- };-- let changed = self.metadata.model != model || self.metadata.supported_models != supported;+ let model = Some(selection.current);+ let changed =+ self.metadata.model != model || self.metadata.supported_models != selection.options;self.metadata.model = model;- self.metadata.supported_models = supported;+ self.metadata.supported_models = selection.options;changed}diff --git a/crates/agent_fold/src/domain/mod.rs b/crates/agent_fold/src/domain/mod.rsindex 83cce2079f..c42ed55dab 100644--- a/crates/agent_fold/src/domain/mod.rs+++ b/crates/agent_fold/src/domain/mod.rs@@ -13,6 +13,8 @@ pub mod ingestion;pub mod log;/// The renderable message vocabulary.pub mod model;+/// Projection of ACP model configuration into domain model choices.+pub mod model_selection;/// The driving query port and the driven log-source port.pub mod ports;/// The domain service answering queries by folding on read.diff --git a/crates/agent_fold/src/domain/model_selection.rs b/crates/agent_fold/src/domain/model_selection.rsnew file mode 100644index 0000000000..cb44e653d6--- /dev/null+++ b/crates/agent_fold/src/domain/model_selection.rs@@ -0,0 +1,74 @@+//! Projection of ACP session configuration into the model selection exposed+//! by the fold and model-discovery callers.++use agent_client_protocol::schema::v1::{+ SessionConfigKind, SessionConfigOption, SessionConfigSelectOptions,+};+use agent_runtime_protocol::domain::action::MODEL_CONFIG_ID;++use crate::domain::model::ModelOption;++#[cfg(test)]+mod test;++/// The current model and ordered choices advertised by an ACP agent.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct ModelSelection {+ /// The model value currently selected by the agent.+ pub current: String,+ /// Models offered by the agent, in advertised order.+ pub options: Vec<ModelOption>,+}++/// Project the ACP `model` select from a complete config-options list.+///+/// Both grouped and ungrouped selects are supported. Groups are flattened in+/// their advertised order. Missing, non-select, and unknown select shapes do+/// not describe a model selection and return `None`.+#[must_use]+pub fn model_selection(options: &[SessionConfigOption]) -> Option<ModelSelection> {+ let model = options+ .iter()+ .find(|option| option.id.to_string() == MODEL_CONFIG_ID)?;+ let SessionConfigKind::Select(select) = &model.kind else {+ return None;+ };++ let options = match &select.options {+ SessionConfigSelectOptions::Ungrouped(options) => options.iter(),+ SessionConfigSelectOptions::Grouped(groups) => {+ return Some(ModelSelection {+ current: select.current_value.to_string(),+ options: groups+ .iter()+ .flat_map(|group| {+ group+ .options+ .iter()+ .map(|option| project_option(option, Some(&group.name)))+ })+ .collect(),+ });+ }+ _ => return None,+ }+ .map(|option| project_option(option, None))+ .collect();++ Some(ModelSelection {+ current: select.current_value.to_string(),+ options,+ })+}++fn project_option(+ option: &agent_client_protocol::schema::v1::SessionConfigSelectOption,+ group: Option<&str>,+) -> ModelOption {+ ModelOption {+ id: option.value.to_string(),+ name: option.name.clone(),+ description: option.description.clone(),+ group: group.map(str::to_owned),+ }+}diff --git a/crates/agent_fold/src/domain/model_selection/test.rs b/crates/agent_fold/src/domain/model_selection/test.rsnew file mode 100644index 0000000000..c5a759cf7e--- /dev/null+++ b/crates/agent_fold/src/domain/model_selection/test.rs@@ -0,0 +1,92 @@+use agent_client_protocol::schema::v1::{+ SessionConfigGroupId, SessionConfigId, SessionConfigOption, SessionConfigSelectGroup,+ SessionConfigSelectOption,+};++use super::*;++fn option(value: &str, name: &str) -> SessionConfigSelectOption {+ SessionConfigSelectOption::new(value.to_owned(), name.to_owned())+}++#[test]+fn projects_ungrouped_models_and_ignores_other_config() {+ let options = vec![+ SessionConfigOption::boolean(SessionConfigId::new("thinking"), "Thinking", true),+ SessionConfigOption::select(+ SessionConfigId::new(MODEL_CONFIG_ID),+ "Model",+ "sonnet",+ vec![+ option("opus", "Opus").description("Largest model"),+ option("sonnet", "Sonnet"),+ ],+ ),+ ];++ let selection = model_selection(&options).expect("the model select should project");++ assert_eq!(selection.current, "sonnet");+ assert_eq!(+ selection.options,+ vec![+ ModelOption {+ id: "opus".to_owned(),+ name: "Opus".to_owned(),+ description: Some("Largest model".to_owned()),+ group: None,+ },+ ModelOption {+ id: "sonnet".to_owned(),+ name: "Sonnet".to_owned(),+ description: None,+ group: None,+ },+ ]+ );+}++#[test]+fn flattens_grouped_models_in_group_and_option_order() {+ let options = vec![SessionConfigOption::select(+ SessionConfigId::new(MODEL_CONFIG_ID),+ "Model",+ "fast",+ vec![+ SessionConfigSelectGroup::new(+ SessionConfigGroupId::new("anthropic"),+ "Anthropic",+ vec![option("smart", "Smart"), option("fast", "Fast")],+ ),+ SessionConfigSelectGroup::new(+ SessionConfigGroupId::new("openai"),+ "OpenAI",+ vec![option("reasoning", "Reasoning").description("Deep reasoning")],+ ),+ ],+ )];++ let selection = model_selection(&options).expect("the grouped model select should project");++ assert_eq!(selection.current, "fast");+ assert_eq!(+ selection+ .options+ .iter()+ .map(|option| option.id.as_str())+ .collect::<Vec<_>>(),+ vec!["smart", "fast", "reasoning"]+ );+ assert_eq!(+ selection.options[2].description.as_deref(),+ Some("Deep reasoning")+ );+ assert_eq!(+ selection+ .options+ .iter()+ .map(|option| option.group.as_deref())+ .collect::<Vec<_>>(),+ vec![Some("Anthropic"), Some("Anthropic"), Some("OpenAI")]+ );+}diff --git a/crates/agent_harness/Cargo.toml b/crates/agent_harness/Cargo.tomlindex 351a6071df..1075394287 100644--- a/crates/agent_harness/Cargo.toml+++ b/crates/agent_harness/Cargo.toml@@ -9,6 +9,7 @@ agent-client-protocol = { workspace = true }# The session-token claim shape and its signing, so the harness and the proxy# cannot disagree about what a token says.agent_egress = { path = "../agent_egress" }+agent_fold = { path = "../agent_fold" }agent_runtime_protocol = { path = "../agent_runtime_protocol" }agent_session = { path = "../agent_session" }agent_trigger = { path = "../agent_trigger" }@@ -55,6 +56,7 @@ tokio-tungstenite = { workspace = true }tracing = { workspace = true }tracing-opentelemetry = { workspace = true }url = { workspace = true }+utoipa = { workspace = true }workspace-hack = { version = "0.1", path = "../workspace-hack" }[dev-dependencies]diff --git a/crates/agent_harness/src/domain/mod.rs b/crates/agent_harness/src/domain/mod.rsindex 3d1e9d8b0a..fbc1b6464c 100644--- a/crates/agent_harness/src/domain/mod.rs+++ b/crates/agent_harness/src/domain/mod.rs@@ -1,5 +1,7 @@pub mod error;pub mod model;+/// Fresh model discovery without creating an agent session.+pub mod model_load;pub mod ports;/// The per-session queue of turn-occupying actions awaiting their turn.pub mod queue;diff --git a/crates/agent_harness/src/domain/model_load.rs b/crates/agent_harness/src/domain/model_load.rsnew file mode 100644index 0000000000..6cc491f1a7--- /dev/null+++ b/crates/agent_harness/src/domain/model_load.rs@@ -0,0 +1,248 @@+//! Domain vocabulary for fresh agent-model discovery.++use std::future::Future;+use std::time::Duration;++use agent_client_protocol::schema::v1::SessionConfigOption;+use agent_fold::domain::model::ModelOption;+use agent_fold::domain::model_selection::model_selection;+use harness_id::HarnessId;+use macro_user_id::user_id::MacroUserIdStr;++#[cfg(test)]+mod test;++/// Provider selected by a model-discovery request.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum ModelHarness {+ /// Macro's in-process agent.+ InMemory,+ /// The caller's Cursor account.+ Cursor,+ /// A paired macrod runtime.+ Macrod,+}++/// One fresh model-discovery request.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct LoadAgentModels {+ /// Provider to inspect.+ pub harness: ModelHarness,+ /// Paired harness identity, required only for [`ModelHarness::Macrod`].+ pub harness_id: Option<HarnessId>,+}++/// Availability of the requested provider's model picker.+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]+#[serde(rename_all = "lowercase")]+pub enum AgentModelsStatus {+ /// A model select was advertised.+ Available,+ /// The provider does not advertise a model select.+ Unsupported,+}++/// Model picker data returned by the use case.+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]+#[serde(rename_all = "camelCase")]+pub struct AgentModels {+ /// Whether model selection is available.+ pub status: AgentModelsStatus,+ /// Currently selected model, absent when unsupported.+ pub current_model: Option<String>,+ /// Ordered model choices.+ pub models: Vec<ModelOption>,+}++impl AgentModels {+ fn from_options(options: &[SessionConfigOption]) -> Self {+ match model_selection(options) {+ Some(selection) => Self {+ status: AgentModelsStatus::Available,+ current_model: Some(selection.current),+ models: selection.options,+ },+ None => Self::unsupported(),+ }+ }++ /// A provider with no model-selection capability.+ #[must_use]+ pub fn unsupported() -> Self {+ Self {+ status: AgentModelsStatus::Unsupported,+ current_model: None,+ models: Vec::new(),+ }+ }+}++/// Raw outcome from a provider probe.+#[derive(Debug)]+pub enum RawModelProbe {+ /// ACP session configuration advertised by the provider.+ Options(Vec<SessionConfigOption>),+ /// This provider cannot advertise models.+ Unsupported,+}++/// A provider probe failure.+#[derive(Debug, thiserror::Error)]+pub enum ModelProbeError {+ /// A required live runtime is not connected.+ #[error("the requested harness is disconnected")]+ Disconnected,+ /// Provider-specific probing failed.+ #[error("model probe failed: {0}")]+ Failed(String),+}++/// Use-case failure.+#[derive(Debug, thiserror::Error)]+pub enum LoadAgentModelsError {+ /// The target shape is invalid.+ #[error("{0}")]+ BadRequest(String),+ /// The caller cannot use or see the target harness.+ #[error("forbidden")]+ Forbidden,+ /// A required runtime is disconnected.+ #[error("the requested harness is disconnected")]+ Disconnected,+ /// The bounded request expired.+ #[error("model probe timed out")]+ Timeout,+ /// A provider failed.+ #[error("model probe failed: {0}")]+ Probe(String),+}++/// Authorizes visibility and use of paired harnesses.+pub trait HarnessModelAccess: Send + Sync + 'static {+ /// Whether `caller` may use and see `harness`.+ fn can_use(+ &self,+ caller: &MacroUserIdStr<'static>,+ harness: HarnessId,+ ) -> impl Future<Output = Result<bool, String>> + Send;+}++/// Fresh in-memory model probe.+pub trait InMemoryModelProbe: Send + Sync + 'static {+ /// Probe the running in-memory implementation.+ fn probe(&self) -> impl Future<Output = Result<RawModelProbe, ModelProbeError>> + Send;+}++/// Fresh Cursor model probe.+pub trait CursorModelProbe: Send + Sync + 'static {+ /// Probe using only the caller's own Cursor credential.+ fn probe(+ &self,+ caller: &MacroUserIdStr<'static>,+ ) -> impl Future<Output = Result<RawModelProbe, ModelProbeError>> + Send;+}++/// Fresh paired-macrod model probe.+pub trait MacrodModelProbe: Send + Sync + 'static {+ /// Probe the live runtime connection for `harness`.+ fn probe(+ &self,+ harness: HarnessId,+ ) -> impl Future<Output = Result<RawModelProbe, ModelProbeError>> + Send;+}++/// Authenticated agent-model discovery use case.+pub trait AgentModelsService: Send + Sync + 'static {+ /// Load one target's model catalog without creating a persisted session.+ fn load(+ &self,+ caller: MacroUserIdStr<'static>,+ request: LoadAgentModels,+ ) -> impl Future<Output = Result<AgentModels, LoadAgentModelsError>> + Send;+}++/// Domain service coordinating authorization, dispatch, timeout, and projection.+pub struct AgentModelsServiceImpl<Access, InMemory, Cursor, Macrod> {+ access: Access,+ in_memory: InMemory,+ cursor: Cursor,+ macrod: Macrod,+ timeout: Duration,+}++impl<Access, InMemory, Cursor, Macrod> AgentModelsServiceImpl<Access, InMemory, Cursor, Macrod> {+ /// Build the service from its outbound ports.+ pub fn new(+ access: Access,+ in_memory: InMemory,+ cursor: Cursor,+ macrod: Macrod,+ timeout: Duration,+ ) -> Self {+ Self {+ access,+ in_memory,+ cursor,+ macrod,+ timeout,+ }+ }+}++impl<Access, InMemory, Cursor, Macrod> AgentModelsService+ for AgentModelsServiceImpl<Access, InMemory, Cursor, Macrod>+where+ Access: HarnessModelAccess,+ InMemory: InMemoryModelProbe,+ Cursor: CursorModelProbe,+ Macrod: MacrodModelProbe,+{+ async fn load(+ &self,+ caller: MacroUserIdStr<'static>,+ request: LoadAgentModels,+ ) -> Result<AgentModels, LoadAgentModelsError> {+ let probe = match (request.harness, request.harness_id) {+ (ModelHarness::InMemory, None) => {+ tokio::time::timeout(self.timeout, self.in_memory.probe())+ .await+ .map_err(|_| LoadAgentModelsError::Timeout)?+ }+ (ModelHarness::Cursor, None) => {+ tokio::time::timeout(self.timeout, self.cursor.probe(&caller))+ .await+ .map_err(|_| LoadAgentModelsError::Timeout)?+ }+ (ModelHarness::Macrod, Some(harness)) => {+ let allowed = self+ .access+ .can_use(&caller, harness)+ .await+ .map_err(LoadAgentModelsError::Probe)?;+ if !allowed {+ return Err(LoadAgentModelsError::Forbidden);+ }+ tokio::time::timeout(self.timeout, self.macrod.probe(harness))+ .await+ .map_err(|_| LoadAgentModelsError::Timeout)?+ }+ (ModelHarness::Macrod, None) => {+ return Err(LoadAgentModelsError::BadRequest(+ "harnessId is required for macrod".to_owned(),+ ));+ }+ (_, Some(_)) => {+ return Err(LoadAgentModelsError::BadRequest(+ "harnessId is only valid for macrod".to_owned(),+ ));+ }+ };++ match probe {+ Ok(RawModelProbe::Options(options)) => Ok(AgentModels::from_options(&options)),+ Ok(RawModelProbe::Unsupported) => Ok(AgentModels::unsupported()),+ Err(ModelProbeError::Disconnected) => Err(LoadAgentModelsError::Disconnected),+ Err(ModelProbeError::Failed(message)) => Err(LoadAgentModelsError::Probe(message)),+ }+ }+}diff --git a/crates/agent_harness/src/domain/model_load/test.rs b/crates/agent_harness/src/domain/model_load/test.rsnew file mode 100644index 0000000000..aec7cc9f32--- /dev/null+++ b/crates/agent_harness/src/domain/model_load/test.rs@@ -0,0 +1,199 @@+use std::sync::atomic::{AtomicUsize, Ordering};+use std::time::Duration;++use agent_client_protocol::schema::v1::{+ SessionConfigOption, SessionConfigSelectOption, SessionConfigValueId,+};++use super::*;++fn caller() -> MacroUserIdStr<'static> {+ MacroUserIdStr::try_from_email("[email protected]").unwrap()+}++fn options() -> Vec<SessionConfigOption> {+ vec![SessionConfigOption::select(+ "model",+ "Model",+ SessionConfigValueId::new("fast"),+ vec![SessionConfigSelectOption::new("fast", "Fast")],+ )]+}++struct Access(bool);++impl HarnessModelAccess for Access {+ async fn can_use(+ &self,+ _caller: &MacroUserIdStr<'static>,+ _harness: HarnessId,+ ) -> Result<bool, String> {+ Ok(self.0)+ }+}++struct Probe {+ calls: AtomicUsize,+ result: fn() -> Result<RawModelProbe, ModelProbeError>,+}++impl Probe {+ fn new(result: fn() -> Result<RawModelProbe, ModelProbeError>) -> Self {+ Self {+ calls: AtomicUsize::new(0),+ result,+ }+ }++ fn calls(&self) -> usize {+ self.calls.load(Ordering::Relaxed)+ }+}++impl InMemoryModelProbe for Probe {+ async fn probe(&self) -> Result<RawModelProbe, ModelProbeError> {+ self.calls.fetch_add(1, Ordering::Relaxed);+ (self.result)()+ }+}++impl CursorModelProbe for Probe {+ async fn probe(+ &self,+ _caller: &MacroUserIdStr<'static>,+ ) -> Result<RawModelProbe, ModelProbeError> {+ self.calls.fetch_add(1, Ordering::Relaxed);+ (self.result)()+ }+}++impl MacrodModelProbe for Probe {+ async fn probe(&self, _harness: HarnessId) -> Result<RawModelProbe, ModelProbeError> {+ self.calls.fetch_add(1, Ordering::Relaxed);+ (self.result)()+ }+}++fn available() -> Result<RawModelProbe, ModelProbeError> {+ Ok(RawModelProbe::Options(options()))+}++fn unsupported() -> Result<RawModelProbe, ModelProbeError> {+ Ok(RawModelProbe::Unsupported)+}++struct HangingCursor;++impl CursorModelProbe for HangingCursor {+ async fn probe(+ &self,+ _caller: &MacroUserIdStr<'static>,+ ) -> Result<RawModelProbe, ModelProbeError> {+ std::future::pending().await+ }+}++#[tokio::test]+async fn macrod_authorizes_before_dispatch_and_projects_the_catalog() {+ let in_memory = Probe::new(unsupported);+ let cursor = Probe::new(unsupported);+ let macrod = Probe::new(available);+ let service = AgentModelsServiceImpl::new(+ Access(true),+ in_memory,+ cursor,+ macrod,+ Duration::from_secs(1),+ );++ let result = service+ .load(+ caller(),+ LoadAgentModels {+ harness: ModelHarness::Macrod,+ harness_id: Some(HarnessId::TEST_A),+ },+ )+ .await+ .unwrap();++ assert_eq!(result.status, AgentModelsStatus::Available);+ assert_eq!(result.current_model.as_deref(), Some("fast"));+ assert_eq!(result.models[0].id, "fast");+ assert_eq!(service.in_memory.calls(), 0);+ assert_eq!(service.cursor.calls(), 0);+ assert_eq!(service.macrod.calls(), 1);+}++#[tokio::test]+async fn invisible_macrod_is_forbidden_without_probing() {+ let service = AgentModelsServiceImpl::new(+ Access(false),+ Probe::new(unsupported),+ Probe::new(unsupported),+ Probe::new(available),+ Duration::from_secs(1),+ );++ let result = service+ .load(+ caller(),+ LoadAgentModels {+ harness: ModelHarness::Macrod,+ harness_id: Some(HarnessId::TEST_A),+ },+ )+ .await;++ assert!(matches!(result, Err(LoadAgentModelsError::Forbidden)));+ assert_eq!(service.macrod.calls(), 0);+}++#[tokio::test]+async fn unsupported_provider_returns_the_supported_response_shape() {+ let service = AgentModelsServiceImpl::new(+ Access(true),+ Probe::new(unsupported),+ Probe::new(available),+ Probe::new(available),+ Duration::from_secs(1),+ );++ let result = service+ .load(+ caller(),+ LoadAgentModels {+ harness: ModelHarness::InMemory,+ harness_id: None,+ },+ )+ .await+ .unwrap();++ assert_eq!(result, AgentModels::unsupported());+ assert_eq!(service.in_memory.calls(), 1);+ assert_eq!(service.cursor.calls(), 0);+}++#[tokio::test]+async fn cursor_probe_obeys_the_service_timeout() {+ let service = AgentModelsServiceImpl::new(+ Access(true),+ Probe::new(unsupported),+ HangingCursor,+ Probe::new(unsupported),+ Duration::from_millis(1),+ );++ let result = service+ .load(+ caller(),+ LoadAgentModels {+ harness: ModelHarness::Cursor,+ harness_id: None,+ },+ )+ .await;++ assert!(matches!(result, Err(LoadAgentModelsError::Timeout)));+}diff --git a/crates/agent_harness/src/inbound/mod.rs b/crates/agent_harness/src/inbound/mod.rsindex 856caaa13c..333a7b10bf 100644--- a/crates/agent_harness/src/inbound/mod.rs+++ b/crates/agent_harness/src/inbound/mod.rs@@ -4,4 +4,6 @@//! is addressed to us, hand one value inward. No policy lives here.pub mod kafka;+/// Authenticated model discovery.+pub mod model_load;pub mod runtime_gateway;diff --git a/crates/agent_harness/src/inbound/model_load.rs b/crates/agent_harness/src/inbound/model_load.rsnew file mode 100644index 0000000000..c8dee480ba--- /dev/null+++ b/crates/agent_harness/src/inbound/model_load.rs@@ -0,0 +1,221 @@+//! Authenticated HTTP adapter for fresh agent-model discovery.++use std::sync::Arc;++use axum::Router;+use axum::extract::{FromRef, Json, State};+use axum::http::StatusCode;+use axum::response::{IntoResponse, Response};+use axum::routing::post;+use harness_id::HarnessId;+use macro_authorization::{+ MacroAuthorizationExtractor, MacroAuthorizationService, MacroAuthorizationState, UserOnly,+};+use macro_uuid::Uuid;+use serde::{Deserialize, Serialize};+use utoipa::ToSchema;++use crate::domain::model_load::{+ AgentModels, AgentModelsService, AgentModelsStatus, LoadAgentModels, LoadAgentModelsError,+ ModelHarness,+};++#[cfg(test)]+mod test;++/// HTTP request selecting one provider to probe.+#[derive(Debug, Deserialize, ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct LoadAgentModelsRequest {+ /// Provider to probe.+ pub harness: ModelHarnessDto,+ /// Required for macrod and forbidden for other targets.+ pub harness_id: Option<Uuid>,+}++/// Harness names accepted by the model discovery endpoint.+#[derive(Debug, Deserialize, ToSchema)]+#[serde(rename_all = "kebab-case")]+pub enum ModelHarnessDto {+ /// Macro's in-process agent.+ InMemory,+ /// The caller's Cursor account.+ Cursor,+ /// A paired macrod runtime.+ Macrod,+}++impl TryFrom<LoadAgentModelsRequest> for LoadAgentModels {+ type Error = LoadAgentModelsError;++ fn try_from(value: LoadAgentModelsRequest) -> Result<Self, Self::Error> {+ let harness = match value.harness {+ ModelHarnessDto::InMemory => ModelHarness::InMemory,+ ModelHarnessDto::Cursor => ModelHarness::Cursor,+ ModelHarnessDto::Macrod => ModelHarness::Macrod,+ };+ Ok(Self {+ harness,+ harness_id: value.harness_id.map(HarnessId::new_from_uuid),+ })+ }+}++/// One model picker option.+#[derive(Debug, Serialize, ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct AgentModelDto {+ /// Provider model id.+ pub id: String,+ /// Display name.+ pub name: String,+ /// Optional provider description.+ pub description: Option<String>,+ /// Optional group heading supplied by the provider.+ pub group: Option<String>,+}++/// Successful model-discovery response.+#[derive(Debug, Serialize, ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct LoadAgentModelsResponse {+ /// Model-selection availability.+ pub status: AgentModelsStatusDto,+ /// Current provider model, if model selection is available.+ pub current_model: Option<String>,+ /// Ordered model catalog.+ pub models: Vec<AgentModelDto>,+}++/// Model-selection availability returned over HTTP.+#[derive(Debug, Serialize, ToSchema)]+#[serde(rename_all = "lowercase")]+pub enum AgentModelsStatusDto {+ /// A model select was advertised.+ Available,+ /// The provider does not advertise model selection.+ Unsupported,+}++impl From<AgentModels> for LoadAgentModelsResponse {+ fn from(value: AgentModels) -> Self {+ Self {+ status: match value.status {+ AgentModelsStatus::Available => AgentModelsStatusDto::Available,+ AgentModelsStatus::Unsupported => AgentModelsStatusDto::Unsupported,+ },+ current_model: value.current_model,+ models: value+ .models+ .into_iter()+ .map(|model| AgentModelDto {+ id: model.id,+ name: model.name,+ description: model.description,+ group: model.group,+ })+ .collect(),+ }+ }+}++/// Router state for model discovery.+pub struct AgentModelsRouterState<Service, Auth> {+ service: Arc<Service>,+ authorization: MacroAuthorizationState<Auth>,+}++impl<Service, Auth> AgentModelsRouterState<Service, Auth> {+ /// Build model-discovery route state.+ pub fn new(service: Arc<Service>, authorization: MacroAuthorizationState<Auth>) -> Self {+ Self {+ service,+ authorization,+ }+ }+}++impl<Service, Auth> Clone for AgentModelsRouterState<Service, Auth> {+ fn clone(&self) -> Self {+ Self {+ service: Arc::clone(&self.service),+ authorization: self.authorization.clone(),+ }+ }+}++impl<Service, Auth> FromRef<AgentModelsRouterState<Service, Auth>>+ for MacroAuthorizationState<Auth>+{+ fn from_ref(state: &AgentModelsRouterState<Service, Auth>) -> Self {+ state.authorization.clone()+ }+}++/// Build `POST /agent-models/load`.+pub fn agent_models_router<Service, Auth, S>(+ state: AgentModelsRouterState<Service, Auth>,+) -> Router<S>+where+ Service: AgentModelsService,+ Auth: MacroAuthorizationService,+ S: Clone + Send + Sync + 'static,+{+ Router::new()+ .route(+ "/agent-models/load",+ post(load_agent_models_handler::<Service, Auth>),+ )+ .with_state(state)+}++/// Probe one provider's model catalog without creating an agent session.+#[utoipa::path(+ post,+ path = "/agent-models/load",+ tag = "agent-models",+ security(("bearerAuth" = [])),+ request_body = LoadAgentModelsRequest,+ responses(+ (status = 200, description = "Fresh provider model catalog", body = LoadAgentModelsResponse),+ (status = 400, description = "Invalid target"),+ (status = 401, description = "Unauthenticated"),+ (status = 403, description = "Harness is not visible to caller"),+ (status = 409, description = "Macrod runtime is disconnected"),+ (status = 504, description = "Macrod probe timed out"),+ (status = 502, description = "Provider probe failed"),+ )+)]+pub async fn load_agent_models_handler<Service, Auth>(+ State(state): State<AgentModelsRouterState<Service, Auth>>,+ authorization: MacroAuthorizationExtractor<Auth, UserOnly>,+ Json(request): Json<LoadAgentModelsRequest>,+) -> Response+where+ Service: AgentModelsService,+ Auth: MacroAuthorizationService,+{+ let request = match request.try_into() {+ Ok(request) => request,+ Err(error) => return model_error_response(error),+ };+ match state+ .service+ .load(authorization.authorization.macro_user_id.clone(), request)+ .await+ {+ Ok(models) => (StatusCode::OK, Json(LoadAgentModelsResponse::from(models))).into_response(),+ Err(error) => model_error_response(error),+ }+}++fn model_error_response(error: LoadAgentModelsError) -> Response {+ let status = match error {+ LoadAgentModelsError::BadRequest(_) => StatusCode::BAD_REQUEST,+ LoadAgentModelsError::Forbidden => StatusCode::FORBIDDEN,+ LoadAgentModelsError::Disconnected => StatusCode::CONFLICT,+ LoadAgentModelsError::Timeout => StatusCode::GATEWAY_TIMEOUT,+ LoadAgentModelsError::Probe(_) => StatusCode::BAD_GATEWAY,+ };+ (status, error.to_string()).into_response()+}diff --git a/crates/agent_harness/src/inbound/model_load/test.rs b/crates/agent_harness/src/inbound/model_load/test.rsnew file mode 100644index 0000000000..77efd93816--- /dev/null+++ b/crates/agent_harness/src/inbound/model_load/test.rs@@ -0,0 +1,75 @@+use axum::body::to_bytes;++use super::*;++#[test]+fn target_request_maps_all_supported_harnesses() {+ let in_memory = LoadAgentModels::try_from(LoadAgentModelsRequest {+ harness: ModelHarnessDto::InMemory,+ harness_id: None,+ })+ .unwrap();+ assert_eq!(in_memory.harness, ModelHarness::InMemory);++ let macrod_id = Uuid::new_v4();+ let macrod = LoadAgentModels::try_from(LoadAgentModelsRequest {+ harness: ModelHarnessDto::Macrod,+ harness_id: Some(macrod_id),+ })+ .unwrap();+ assert_eq!(macrod.harness, ModelHarness::Macrod);+ assert_eq!(macrod.harness_id.unwrap().as_uuid(), macrod_id);+}++#[test]+fn handler_errors_map_to_transport_statuses() {+ for (error, status) in [+ (+ LoadAgentModelsError::BadRequest("bad".to_owned()),+ StatusCode::BAD_REQUEST,+ ),+ (LoadAgentModelsError::Forbidden, StatusCode::FORBIDDEN),+ (LoadAgentModelsError::Disconnected, StatusCode::CONFLICT),+ (LoadAgentModelsError::Timeout, StatusCode::GATEWAY_TIMEOUT),+ (+ LoadAgentModelsError::Probe("failed".to_owned()),+ StatusCode::BAD_GATEWAY,+ ),+ ] {+ assert_eq!(model_error_response(error).status(), status);+ }+}++#[tokio::test]+async fn successful_response_serializes_available_catalog() {+ let response = (+ StatusCode::OK,+ Json(LoadAgentModelsResponse::from(AgentModels {+ status: AgentModelsStatus::Available,+ current_model: Some("fast".to_owned()),+ models: vec![agent_fold::domain::model::ModelOption {+ id: "fast".to_owned(),+ name: "Fast".to_owned(),+ description: None,+ group: None,+ }],+ })),+ )+ .into_response();++ assert_eq!(response.status(), StatusCode::OK);+ let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();+ assert_eq!(+ serde_json::from_slice::<serde_json::Value>(&body).unwrap(),+ serde_json::json!({+ "status": "available",+ "currentModel": "fast",+ "models": [{+ "id": "fast",+ "name": "Fast",+ "description": null,+ "group": null+ }]+ })+ );+}diff --git a/crates/agent_harness/src/outbound/runtime_registry.rs b/crates/agent_harness/src/outbound/runtime_registry.rsindex e88bc6e106..c6f5e34828 100644--- a/crates/agent_harness/src/outbound/runtime_registry.rs+++ b/crates/agent_harness/src/outbound/runtime_registry.rs@@ -63,6 +63,26 @@ wherepub fn is_connected(&self, harness: HarnessId) -> bool {self.connections.contains_key(&harness)}++ /// Ask a harness's live runtime to probe a fresh ACP process.+ ///+ /// Returns `None` when no live connection exists. The caller owns the+ /// request deadline because timeout is use-case policy.+ pub async fn probe_models(+ &self,+ harness: HarnessId,+ ) -> Option<+ Result<+ Vec<agent_client_protocol::schema::v1::SessionConfigOption>,+ agent_session::domain::connection::ModelProbeError,+ >,+ > {+ let connection = self+ .connections+ .get(&harness)+ .map(|entry| Arc::clone(&entry))?;+ Some(connection.probe_models().await)+ }}impl<Sender> RuntimeRegistry<Sender>diff --git a/crates/agent_inmem/Cargo.toml b/crates/agent_inmem/Cargo.tomlindex ce7bb90f9b..3fa4a72254 100644--- a/crates/agent_inmem/Cargo.toml+++ b/crates/agent_inmem/Cargo.toml@@ -19,6 +19,7 @@ ai_usage = { path = "../ai_usage" }bytes = { workspace = true }async-trait = { workspace = true }axum = { workspace = true }+chat = { path = "../chat", default-features = false }dashmap = { workspace = true }futures = { workspace = true }macro_user_id = { path = "../macro_user_id" }diff --git a/crates/agent_inmem/src/domain/agent.rs b/crates/agent_inmem/src/domain/agent.rsindex 0b1a695c3c..9166dd5078 100644--- a/crates/agent_inmem/src/domain/agent.rs+++ b/crates/agent_inmem/src/domain/agent.rs@@ -21,11 +21,11 @@ use agent_client_protocol::schema::v1::{ElicitationSchema, ElicitationSessionScope, EnumOption, Implementation, InitializeRequest,InitializeResponse, IntegerPropertySchema, Meta, NewSessionRequest, NewSessionResponse,NumberPropertySchema, OtherElicitationPropertySchema, PromptRequest, PromptResponse,- ResumeSessionRequest, ResumeSessionResponse, SessionCapabilities, SessionId,- SessionNotification, SessionResumeCapabilities, SessionUpdate, SetSessionConfigOptionRequest,- SetSessionConfigOptionResponse, StopReason, StringFormat, StringPropertySchema,- ToolCall as AcpToolCall, ToolCallId, ToolCallStatus, ToolCallUpdate, ToolCallUpdateFields,- ToolKind,+ ResumeSessionRequest, ResumeSessionResponse, SessionCapabilities, SessionConfigOption,+ SessionId, SessionNotification, SessionResumeCapabilities, SessionUpdate,+ SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, StopReason, StringFormat,+ StringPropertySchema, ToolCall as AcpToolCall, ToolCallId, ToolCallStatus, ToolCallUpdate,+ ToolCallUpdateFields, ToolKind,};use agent_client_protocol::{Agent, Channel as AcpChannel, Client, ConnectionTo, Error as AcpError,@@ -179,6 +179,18 @@ impl AgentState {}}+ /// ACP model configuration backed by the engine's supported-model source+ /// and this session's current selection.+ fn model_config_options(&self) -> Vec<SessionConfigOption> {+ let Some(session) = self.store.get(&self.session_id) else {+ return Vec::new();+ };+ crate::domain::model_options::model_config_options(+ &session.model,+ self.engine.supported_models(),+ )+ }+/// Everything from the session's state that a turn answering `prompt`/// runs from.fn turn_input(&self, prompt: &str) -> TurnInput {@@ -504,7 +516,10 @@ pub async fn serve(state: Arc<AgentState>, acp: AcpChannel) -> Result<(), AcpErrlet acp_id = SessionId::new(macro_uuid::generate_uuid_v7().to_string());state.bind_acp_session(acp_id.clone(), false);state.connect_mcp(request.mcp_servers).await;- responder.respond(NewSessionResponse::new(acp_id))+ responder.respond(+ NewSessionResponse::new(acp_id)+ .config_options(state.model_config_options()),+ )}},agent_client_protocol::on_receive_request!(),diff --git a/crates/agent_inmem/src/domain/agent/test.rs b/crates/agent_inmem/src/domain/agent/test.rsindex f0bd38a021..05c0508453 100644--- a/crates/agent_inmem/src/domain/agent/test.rs+++ b/crates/agent_inmem/src/domain/agent/test.rs@@ -21,6 +21,10 @@ struct Harness {struct CancelledEngine;impl TurnEngine for CancelledEngine {+ fn supported_models(&self) -> &[&str] {+ crate::testing::TEST_MODELS+ }+fn run_turn(&self,_request: TurnRequest,@@ -44,7 +48,7 @@ impl TurnEngine for CancelledEngine {async fn with_agent<Engine, Out>(engine: Arc<Engine>,scenario: impl AsyncFnOnce(ConnectionTo<Agent>, SessionId) -> Out,-) -> (Vec<SessionNotification>, Out)+) -> (Vec<SessionNotification>, Vec<SessionConfigOption>, Out)whereEngine: TurnEngine,{@@ -114,7 +118,8 @@ where.send_request(NewSessionRequest::new("/")).block_task().await?;- Ok(scenario(connection, session.session_id).await)+ let out = scenario(connection, session.session_id).await;+ Ok((session.config_options, out))},).await@@ -126,7 +131,7 @@ where.lock().expect("notifications lock").clone();- (notifications, out)+ (notifications, out.0.unwrap_or_default(), out.1)}fn text_prompt(session: &SessionId, text: &str) -> PromptRequest {@@ -136,6 +141,24 @@ fn text_prompt(session: &SessionId, text: &str) -> PromptRequest {)}+#[tokio::test]+async fn new_session_advertises_the_engine_supported_models() {+ let (_notifications, config_options, ()) =+ with_agent(Arc::new(ScriptedEngine::new(vec![])), async |_, _| {}).await;++ let selection = agent_fold::domain::model_selection::model_selection(&config_options)+ .expect("session/new should advertise a model select");+ assert_eq!(selection.current, "test-model");+ assert_eq!(+ selection+ .options+ .iter()+ .map(|model| (model.id.as_str(), model.name.as_str()))+ .collect::<Vec<_>>(),+ vec![("test-model", "test-model"), ("other-model", "other-model")]+ );+}+#[tokio::test]async fn a_prompt_streams_updates_and_ends_the_turn() {let engine = Arc::new(ScriptedEngine::new(vec![@@ -155,14 +178,15 @@ async fn a_prompt_streams_updates_and_ends_the_turn() {StreamPart::Content("world".into()),]));- let (notifications, response) = with_agent(Arc::clone(&engine), async |connection, session| {- connection- .send_request(text_prompt(&session, "find the roadmap"))- .block_task()- .await- .expect("the prompt should complete")- })- .await;+ let (notifications, _config_options, response) =+ with_agent(Arc::clone(&engine), async |connection, session| {+ connection+ .send_request(text_prompt(&session, "find the roadmap"))+ .block_task()+ .await+ .expect("the prompt should complete")+ })+ .await;assert_eq!(response.stop_reason, StopReason::EndTurn);let kinds: Vec<&'static str> = notifications@@ -217,7 +241,7 @@ async fn tool_calls_are_stamped_with_their_names_and_subagent_flag() {}),]));- let (notifications, _) = with_agent(Arc::clone(&engine), async |connection, session| {+ let (notifications, _, _) = with_agent(Arc::clone(&engine), async |connection, session| {connection.send_request(text_prompt(&session, "go")).block_task()@@ -308,25 +332,27 @@ async fn compact_clears_history_without_running_a_turn() {async fn cancel_stops_the_turn_with_the_cancelled_stop_reason() {let engine = Arc::new(HangingEngine);- let (_notifications, response) = with_agent(engine, async |connection, session| {- let pending = connection.send_request(text_prompt(&session, "hang"));- let cancel = agent_client_protocol::schema::v1::CancelNotification::new(session.clone());- connection- .send_notification(cancel)- .expect("the cancel notification should send");- pending- .block_task()- .await- .expect("a cancelled prompt still completes")- })- .await;+ let (_notifications, _config_options, response) =+ with_agent(engine, async |connection, session| {+ let pending = connection.send_request(text_prompt(&session, "hang"));+ let cancel =+ agent_client_protocol::schema::v1::CancelNotification::new(session.clone());+ connection+ .send_notification(cancel)+ .expect("the cancel notification should send");+ pending+ .block_task()+ .await+ .expect("a cancelled prompt still completes")+ })+ .await;assert_eq!(response.stop_reason, StopReason::Cancelled);}#[tokio::test]async fn engine_cancellation_is_not_rendered_as_an_error_message() {- let (notifications, response) =+ let (notifications, _config_options, response) =with_agent(Arc::new(CancelledEngine), async |connection, session| {connection.send_request(text_prompt(&session, "cancel me"))@@ -728,6 +754,10 @@ async fn ask_reports_a_decline_and_a_free_text_question_has_no_options() {struct AskingEngine;impl TurnEngine for AskingEngine {+ fn supported_models(&self) -> &[&str] {+ crate::testing::TEST_MODELS+ }+fn run_turn(&self,request: TurnRequest,@@ -794,6 +824,10 @@ async fn a_turn_waiting_on_the_user_outlasts_the_idle_timeout() {struct ReviewingEngine;impl TurnEngine for ReviewingEngine {+ fn supported_models(&self) -> &[&str] {+ crate::testing::TEST_MODELS+ }+fn run_turn(&self,request: TurnRequest,@@ -952,7 +986,7 @@ async fn a_user_tool_review_is_a_tool_scoped_form_elicitation_naming_the_tool()/// The timeout still guards a turn that is silent with nothing asked.#[tokio::test(start_paused = true)]async fn a_silent_turn_with_no_question_out_is_stopped_by_the_idle_timeout() {- let (notifications, response) =+ let (notifications, _config_options, response) =with_agent(Arc::new(HangingEngine), async |connection, session| {connection.send_request(text_prompt(&session, "hang"))@@ -973,14 +1007,15 @@ async fn a_silent_turn_with_no_question_out_is_stopped_by_the_idle_timeout() {#[tokio::test]async fn ask_without_form_support_explains_instead_of_asking() {let engine = Arc::new(ScriptedEngine::new(vec![]));- let (notifications, response) = with_agent(engine, async |connection, session| {- connection- .send_request(text_prompt(&session, "/ask anything?"))- .block_task()- .await- .expect("the ask should complete")- })- .await;+ let (notifications, _config_options, response) =+ with_agent(engine, async |connection, session| {+ connection+ .send_request(text_prompt(&session, "/ask anything?"))+ .block_task()+ .await+ .expect("the ask should complete")+ })+ .await;assert_eq!(response.stop_reason, StopReason::EndTurn);assert!(diff --git a/crates/agent_inmem/src/domain/engine.rs b/crates/agent_inmem/src/domain/engine.rsindex 3f1997917e..81aca7fba0 100644--- a/crates/agent_inmem/src/domain/engine.rs+++ b/crates/agent_inmem/src/domain/engine.rs@@ -48,6 +48,10 @@ pub struct TurnRequest {/// scripted engine, and production plugs in/// [`crate::rig_engine::RigTurnEngine`].pub trait TurnEngine: Send + Sync + 'static {+ /// Model ids this engine deployment can run and therefore advertises over+ /// ACP. The order is the picker order.+ fn supported_models(&self) -> &[&str];+/// Start the turn. Parts arrive on the returned receiver; the stream/// ending is the turn ending, and an `Err` item is a turn-fatal failure.fn run_turn(&self, request: TurnRequest) -> mpsc::Receiver<Result<StreamPart, AgentError>>;diff --git a/crates/agent_inmem/src/domain/mod.rs b/crates/agent_inmem/src/domain/mod.rsindex 4864334f33..ea26c77042 100644--- a/crates/agent_inmem/src/domain/mod.rs+++ b/crates/agent_inmem/src/domain/mod.rs@@ -4,6 +4,8 @@pub mod agent;pub mod engine;pub mod mcp;+/// ACP model configuration generated from the turn engine catalog.+pub mod model_options;pub mod replay;pub mod session;pub mod user_input;diff --git a/crates/agent_inmem/src/domain/model_options.rs b/crates/agent_inmem/src/domain/model_options.rsnew file mode 100644index 0000000000..c306562e6b--- /dev/null+++ b/crates/agent_inmem/src/domain/model_options.rs@@ -0,0 +1,23 @@+//! ACP model configuration advertised by the in-memory agent.++use agent_client_protocol::schema::v1::{+ SessionConfigOption, SessionConfigSelectOption, SessionConfigValueId,+};+use agent_runtime_protocol::domain::action::MODEL_CONFIG_ID;++/// Build model configuration from the actual turn engine catalog.+#[must_use]+pub fn model_config_options(current: &str, models: &[&str]) -> Vec<SessionConfigOption> {+ let options: Vec<_> = models+ .iter()+ .map(|model| {+ SessionConfigSelectOption::new(SessionConfigValueId::new((*model).to_owned()), *model)+ })+ .collect();+ vec![SessionConfigOption::select(+ MODEL_CONFIG_ID,+ "Model",+ SessionConfigValueId::new(current.to_owned()),+ options,+ )]+}diff --git a/crates/agent_inmem/src/rig_engine.rs b/crates/agent_inmem/src/rig_engine.rsindex 917b81b53b..29928df330 100644--- a/crates/agent_inmem/src/rig_engine.rs+++ b/crates/agent_inmem/src/rig_engine.rs@@ -93,6 +93,10 @@ fn tools_for_turn(}impl TurnEngine for RigTurnEngine {+ fn supported_models(&self) -> &[&str] {+ chat::domain::models::CHAT_MODELS+ }+fn run_turn(&self, request: TurnRequest) -> mpsc::Receiver<Result<StreamPart, AgentError>> {let (parts, receiver) = mpsc::channel(PART_BUFFER);let db = self.db.clone();diff --git a/crates/agent_inmem/src/testing.rs b/crates/agent_inmem/src/testing.rsindex fbdb765f23..c07856570a 100644--- a/crates/agent_inmem/src/testing.rs+++ b/crates/agent_inmem/src/testing.rs@@ -5,6 +5,9 @@ use tokio::sync::mpsc;use crate::domain::engine::{TurnEngine, TurnRequest};+/// Models advertised by shared test engines.+pub(crate) const TEST_MODELS: &[&str] = &["test-model", "other-model"];+/// An engine that plays back a script of parts for every turn.pub(crate) struct ScriptedEngine {script: Vec<StreamPart>,@@ -37,6 +40,10 @@ impl ScriptedEngine {}impl TurnEngine for ScriptedEngine {+ fn supported_models(&self) -> &[&str] {+ TEST_MODELS+ }+fn run_turn(&self, request: TurnRequest) -> mpsc::Receiver<Result<StreamPart, AgentError>> {self.requests.lock()@@ -67,6 +74,10 @@ impl TurnEngine for ScriptedEngine {pub(crate) struct HangingEngine;impl TurnEngine for HangingEngine {+ fn supported_models(&self) -> &[&str] {+ TEST_MODELS+ }+fn run_turn(&self, request: TurnRequest) -> mpsc::Receiver<Result<StreamPart, AgentError>> {let (parts, receiver) = mpsc::channel(1);tokio::spawn(async move {diff --git a/crates/agent_runtime_protocol/src/domain/action.rs b/crates/agent_runtime_protocol/src/domain/action.rsindex 40c3fdc03d..d7e75a9b54 100644--- a/crates/agent_runtime_protocol/src/domain/action.rs+++ b/crates/agent_runtime_protocol/src/domain/action.rs@@ -320,7 +320,9 @@ impl AgentAction {return Some(Self::SetModel(action));}- let ToRuntimeMessage::Acp(AcpMessage(frame)) = message;+ let ToRuntimeMessage::Acp(AcpMessage(frame)) = message else {+ return None;+ };match frame {RawJsonRpcMessage::Request(request)if PromptRequest::matches_method(&request.method) =>diff --git a/crates/agent_runtime_protocol/src/domain/connection.rs b/crates/agent_runtime_protocol/src/domain/connection.rsindex 857c5a8b43..e9e155e1cb 100644--- a/crates/agent_runtime_protocol/src/domain/connection.rs+++ b/crates/agent_runtime_protocol/src/domain/connection.rs@@ -6,13 +6,18 @@//! all of this connection's ACP traffic.use std::future::Future;+use std::sync::Arc;+use agent_client_protocol::schema::v1::SessionConfigOption;use agent_client_protocol::{Channel as AcpChannel, TransportFrame};use futures::StreamExt;use tokio::sync::mpsc::UnboundedSender;+use tokio::task::JoinSet;use crate::domain::channel::Channel;-use crate::domain::schema::v0::{AcpMessage, SystemEvent, ToRuntimeMessage, ToServerMessage};+use crate::domain::schema::v0::{+ AcpMessage, ModelProbeResult, SystemEvent, ToRuntimeMessage, ToServerMessage,+};#[cfg(test)]mod test;@@ -36,6 +41,18 @@ impl SystemEventHandler for () {}}+/// Handles connection-level requests to inspect a fresh ACP subprocess.+pub trait ModelProbeHandler: Send + Sync + 'static {+ /// Return the raw `session/new` options or a safe error message.+ fn probe(&self) -> impl Future<Output = Result<Vec<SessionConfigOption>, String>> + Send;+}++impl ModelProbeHandler for () {+ async fn probe(&self) -> Result<Vec<SessionConfigOption>, String> {+ Err("model probing is not configured on this runtime".to_owned())+ }+}+/// A failure while using a logical protocol connection.#[derive(Debug, thiserror::Error)]#[non_exhaustive]@@ -91,13 +108,31 @@ impl RuntimeConnection {/// [`AcpChannel`] for the single agent execution this connection hosts.#[must_use]pub fn connect(channel: RuntimeChannel) -> (Self, AcpChannel) {+ Self::connect_with_model_probe_handler(channel, ())+ }++ /// Attach the runtime role and handle model probes outside the primary ACP+ /// process. Every request is allowed to run concurrently.+ #[must_use]+ pub fn connect_with_model_probe_handler<H>(+ channel: RuntimeChannel,+ model_probes: H,+ ) -> (Self, AcpChannel)+ where+ H: ModelProbeHandler,+ {let Channel {tx: outbound,rx: inbound,} = channel;let (acp, acp_driver) = AcpChannel::duplex();- let driver =- tokio::spawn(run_runtime(inbound, outbound.clone(), acp_driver)).abort_handle();+ let driver = tokio::spawn(run_runtime(+ inbound,+ outbound.clone(),+ acp_driver,+ Arc::new(model_probes),+ ))+ .abort_handle();(Self { outbound, driver }, acp)}@@ -145,6 +180,9 @@ async fn run_server<H>(acp_open = false;}}+ ToServerMessage::ModelProbeResponse { .. } => {+ tracing::warn!("dropping a model probe response without a probe waiter");+ }}}message = acp.rx.next(), if acp_open => {@@ -169,14 +207,20 @@ async fn run_server<H>(}}-async fn run_runtime(+async fn run_runtime<H>(mut inbound: tokio::sync::mpsc::UnboundedReceiver<ToRuntimeMessage>,outbound: UnboundedSender<ToServerMessage>,mut acp: AcpChannel,-) {+ model_probes: Arc<H>,+) where+ H: ModelProbeHandler,+{// See the matching comment in `run_server`: dropping the ACP channel must// not tear down this connection - only an actual transport failure does.let mut acp_open = true;+ // Owned by the connection driver: dropping the runtime connection aborts+ // every subprocess-backed probe still in flight.+ let mut probes = JoinSet::new();loop {tokio::select! {message = inbound.recv() => {@@ -191,6 +235,24 @@ async fn run_runtime(acp_open = false;}}+ ToRuntimeMessage::ModelProbeRequest => {+ let model_probes = Arc::clone(&model_probes);+ let outbound = outbound.clone();+ probes.spawn(async move {+ let result = match model_probes.probe().await {+ Ok(config_options) => {+ ModelProbeResult::Available { config_options }+ }+ Err(message) => ModelProbeResult::Error { message },+ };+ let _ = outbound.send(ToServerMessage::ModelProbeResponse { result });+ });+ }+ }+ }+ result = probes.join_next(), if !probes.is_empty() => {+ if let Some(Err(error)) = result {+ tracing::warn!(%error, "model probe task failed");}}message = acp.rx.next(), if acp_open => {diff --git a/crates/agent_runtime_protocol/src/domain/connection/test.rs b/crates/agent_runtime_protocol/src/domain/connection/test.rsindex f33a50c843..71c7d52bb0 100644--- a/crates/agent_runtime_protocol/src/domain/connection/test.rs+++ b/crates/agent_runtime_protocol/src/domain/connection/test.rs@@ -192,3 +192,88 @@ async fn official_acp_client_and_agent_connect_directly_to_exposed_channels() {"the long-lived agent driver should only be stopped explicitly");}++struct ProbeHandler;++impl ModelProbeHandler for ProbeHandler {+ async fn probe(+ &self,+ ) -> Result<Vec<agent_client_protocol::schema::v1::SessionConfigOption>, String> {+ Ok(Vec::new())+ }+}++#[tokio::test]+async fn runtime_answers_a_model_probe_with_the_agent_options() {+ let (mut service, runtime_channel) = Channel::duplex();+ let (_runtime, _runtime_acp) =+ RuntimeConnection::connect_with_model_probe_handler(runtime_channel, ProbeHandler);++ service+ .tx+ .send(ToRuntimeMessage::ModelProbeRequest)+ .expect("request should send");+ let response = timeout(Duration::from_secs(1), service.rx.recv())+ .await+ .expect("probe response should not hang")+ .expect("runtime should remain connected");++ assert!(matches!(+ response,+ ToServerMessage::ModelProbeResponse {+ result: crate::domain::schema::v0::ModelProbeResult::Available { config_options },+ } if config_options.is_empty()+ ));+}++struct ConcurrentProbeHandler {+ started: tokio::sync::mpsc::UnboundedSender<()>,+ release: Arc<tokio::sync::Notify>,+}++impl ModelProbeHandler for ConcurrentProbeHandler {+ async fn probe(+ &self,+ ) -> Result<Vec<agent_client_protocol::schema::v1::SessionConfigOption>, String> {+ let _ = self.started.send(());+ self.release.notified().await;+ Ok(Vec::new())+ }+}++#[tokio::test]+async fn runtime_model_probes_fan_out_without_serializing() {+ let (mut service, runtime_channel) = Channel::duplex();+ let (started, mut starts) = tokio::sync::mpsc::unbounded_channel();+ let release = Arc::new(tokio::sync::Notify::new());+ let (_runtime, _runtime_acp) = RuntimeConnection::connect_with_model_probe_handler(+ runtime_channel,+ ConcurrentProbeHandler {+ started,+ release: Arc::clone(&release),+ },+ );++ for _ in 0..2 {+ service+ .tx+ .send(ToRuntimeMessage::ModelProbeRequest)+ .expect("request should send");+ }+ for _ in 0..2 {+ timeout(Duration::from_secs(1), starts.recv())+ .await+ .expect("both probes should start while neither can finish")+ .expect("the handler should outlive the test");+ }+ release.notify_waiters();++ for _ in 0..2 {+ assert!(matches!(+ timeout(Duration::from_secs(1), service.rx.recv())+ .await+ .expect("response should not hang"),+ Some(ToServerMessage::ModelProbeResponse { .. })+ ));+ }+}diff --git a/crates/agent_runtime_protocol/src/domain/schema/v0.rs b/crates/agent_runtime_protocol/src/domain/schema/v0.rsindex fb4515becc..2b6bedfab6 100644--- a/crates/agent_runtime_protocol/src/domain/schema/v0.rs+++ b/crates/agent_runtime_protocol/src/domain/schema/v0.rs@@ -12,6 +12,7 @@//! the agent's raw ACP traffic.use agent_client_protocol::RawJsonRpcMessage;+use agent_client_protocol::schema::v1::SessionConfigOption;use serde::{Deserialize, Deserializer, Serialize, Serializer};use specta::Type;use specta_typescript::Unknown;@@ -106,6 +107,24 @@ pub struct AcpMessage(#[specta(type = std::collections::HashMap<String, Unknown>)] pub RawJsonRpcMessage,);+/// The result of probing a fresh ACP subprocess.+#[derive(Debug, Clone, Serialize, Deserialize, Type)]+#[serde(tag = "status", rename_all = "camelCase")]+pub enum ModelProbeResult {+ /// The raw options returned by `session/new`.+ Available {+ /// Session configuration options exactly as the agent returned them.+ #[serde(rename = "configOptions")]+ #[specta(type = Vec<Unknown>)]+ config_options: Vec<SessionConfigOption>,+ },+ /// A safe, operator-actionable failure description.+ Error {+ /// Failure text safe to return across the runtime connection.+ message: String,+ },+}+/// Agent Service to Agent Runtime traffic on the logical protocol stream.#[derive(Debug, Clone, Serialize, Deserialize, Type)]#[serde(tag = "type", rename_all = "camelCase")]@@ -113,6 +132,12 @@ pub struct AcpMessage(pub enum ToRuntimeMessage {/// An ACP message routed to the hosted agent.Acp(AcpMessage),+ /// Probe a separate fresh agent process for its session configuration.+ ///+ /// The request carries no parameters: it asks this connection's one+ /// configured harness what it advertises. Answers are therefore+ /// interchangeable, so nothing correlates a response to a request.+ ModelProbeRequest,}/// Agent Runtime to Agent Service traffic on the logical protocol stream.@@ -128,4 +153,9 @@ pub enum ToServerMessage {#[specta(type = String)]event: SystemEvent,},+ /// An answer to a connection-level model probe.+ ModelProbeResponse {+ /// Raw options or a safe failure.+ result: ModelProbeResult,+ },}diff --git a/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs b/crates/agent_runtime_protocol/src/domain/schema/v0/test.rsindex 7137977ac3..98fffa119c 100644--- a/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs+++ b/crates/agent_runtime_protocol/src/domain/schema/v0/test.rs@@ -98,7 +98,10 @@ fn acp_message_contains_an_acp_raw_jsonrpc_message() {);let ToRuntimeMessage::Acp(AcpMessage(parsed)) =- serde_json::from_value::<ToRuntimeMessage>(message).unwrap();+ serde_json::from_value::<ToRuntimeMessage>(message).unwrap()+ else {+ panic!("expected ACP message")+ };assert_eq!(serde_json::to_value(parsed).unwrap(),json!({@@ -111,3 +114,28 @@ fn acp_message_contains_an_acp_raw_jsonrpc_message() {}));}++#[test]+fn model_probe_messages_carry_no_session_id_and_no_correlation() {+ let request = ToRuntimeMessage::ModelProbeRequest;+ let response = ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Available {+ config_options: Vec::new(),+ },+ };++ assert_eq!(+ serde_json::to_value(request).unwrap(),+ json!({ "type": "modelProbeRequest" })+ );+ assert_eq!(+ serde_json::to_value(response).unwrap(),+ json!({+ "type": "modelProbeResponse",+ "result": {+ "status": "available",+ "configOptions": [],+ },+ })+ );+}diff --git a/crates/agent_session/src/domain/connection.rs b/crates/agent_session/src/domain/connection.rsindex ca0d0aae62..35ad521a10 100644--- a/crates/agent_session/src/domain/connection.rs+++ b/crates/agent_session/src/domain/connection.rs@@ -28,7 +28,7 @@ use agent_runtime_protocol::domain::ports::{Transport, TransportError, TransportReceiver, TransportSender,};use agent_runtime_protocol::domain::schema::v0::{- AcpMessage, SystemEvent, ToRuntimeMessage, ToServerMessage,+ AcpMessage, ModelProbeResult, SystemEvent, ToRuntimeMessage, ToServerMessage,};use dashmap::DashMap;use tokio::sync::{Mutex, mpsc, watch};@@ -57,6 +57,8 @@ pub(crate) enum Routed {Session(AgentSessionId),/// The whole connection's business: a system event, or its end.Connection,+ /// A connection-level model probe response, never session traffic.+ Probe,/// Nothing owns it. Kept as its own answer rather than folded into/// `Connection` so it can be counted and logged as the anomaly it is.Orphan,@@ -94,6 +96,9 @@ impl Routes {/// expectation is consumed - a second answer to one request has no owner./// Anything carrying a `sessionId` belongs to that ACP session's owner.pub(crate) fn route(&mut self, message: &ToServerMessage) -> Routed {+ if matches!(message, ToServerMessage::ModelProbeResponse { .. }) {+ return Routed::Probe;+ }let ToServerMessage::Acp(AcpMessage(frame)) = message else {return Routed::Connection;};@@ -195,6 +200,9 @@ impl<Connector> RuntimeAttachment<Connector> {/// Every session this connection carries, and where to reach it.type Bound = DashMap<AgentSessionId, mpsc::Sender<ToServerMessage>>;+/// The latest model probe answer, or `None` for "no answer is coming".+type ProbeAnswers = watch::Sender<Option<ModelProbeResult>>;+/// One runtime connection and the sessions riding on it.////// Holds the carrier's sending half only: the receiving half belongs to the@@ -210,6 +218,10 @@ pub struct RuntimeConnection<Sender> {/// afterwards has to be able to learn it happened.runtime_ready: AtomicBool,bound: Bound,+ /// Answers to model probes, broadcast rather than correlated: every probe+ /// on this connection asks the same parameterless question, so any answer+ /// serves any waiter.+ probe_answers: ProbeAnswers,routes: Mutex<Routes>,router: OnceLock<tokio::task::AbortHandle>,/// Cancelled once this connection's transport has ended.@@ -241,6 +253,7 @@ wherehandshake,runtime_ready: AtomicBool::new(false),bound: DashMap::new(),+ probe_answers: watch::channel(None).0,routes: Mutex::new(Routes::default()),router: OnceLock::new(),closed: CancellationToken::new(),@@ -253,6 +266,8 @@ where/// Stop serving this connection: it has been displaced by a newer dial.pub fn evict(&self) {self.bound.clear();+ // Nothing will answer a probe on a connection that is no longer served.+ let _ = self.probe_answers.send(None);if let Some(router) = self.router.get() {router.abort();}@@ -271,6 +286,40 @@ whereself.closed.cancelled().await;}+ /// Ask the runtime to inspect a separate fresh ACP process and await the+ /// next answer this connection produces.+ ///+ /// Answers are not correlated to requests because they cannot disagree:+ /// the request has no parameters and the runtime hosts one configured+ /// harness, so concurrent probes are the same question asked twice.+ pub async fn probe_models(+ &self,+ ) -> Result<Vec<agent_client_protocol::schema::v1::SessionConfigOption>, ModelProbeError> {+ // Subscribe before asking: an answer can land before this task is+ // polled again, and a missed wakeup would wait for somebody else's+ // next probe.+ let mut answers = self.probe_answers.subscribe();+ answers.mark_unchanged();++ self.outbound+ .send(ToRuntimeMessage::ModelProbeRequest)+ .await+ .map_err(ModelProbeError::Transport)?;++ let answer = tokio::select! {+ changed = answers.changed() => {+ changed.map_err(|_| ModelProbeError::Closed)?;+ answers.borrow_and_update().clone()+ }+ () = self.closed.cancelled() => return Err(ModelProbeError::Closed),+ };+ match answer {+ Some(ModelProbeResult::Available { config_options }) => Ok(config_options),+ Some(ModelProbeResult::Error { message }) => Err(ModelProbeError::Runtime(message)),+ None => Err(ModelProbeError::Closed),+ }+ }+/// The gate every session on this connection shares.pub fn handshake(&self) -> watch::Sender<HandshakeStatus> {self.handshake.clone()@@ -368,6 +417,7 @@ wherematch routed {Routed::Session(session) => self.deliver(session, message).await,Routed::Connection => self.on_connection_message(message).await,+ Routed::Probe => self.answer_probes(message),Routed::Orphan => {tracing::warn!(frame = ?message,@@ -380,6 +430,15 @@ whereself.closed.cancel();}+ /// Hand one answer to every probe waiting on this connection. An answer+ /// nobody is waiting for is simply the last one, and is dropped.+ fn answer_probes(&self, message: ToServerMessage) {+ let ToServerMessage::ModelProbeResponse { result } = message else {+ unreachable!("only model probe responses receive probe routing")+ };+ let _ = self.probe_answers.send(Some(result));+ }+async fn deliver(&self, session: AgentSessionId, message: ToServerMessage) {let Some(inbound) = self.bound.get(&session).map(|entry| entry.clone()) else {tracing::warn!(%session, "a frame arrived for a session that has gone");@@ -458,6 +517,21 @@ where}}+/// A connection-level model probe failure.+#[derive(Debug, thiserror::Error)]+#[non_exhaustive]+pub enum ModelProbeError {+ /// Sending the request over the runtime transport failed.+ #[error("could not send model probe request: {0}")]+ Transport(#[source] TransportError),+ /// The runtime connection closed before answering.+ #[error("runtime connection closed before answering the model probe")]+ Closed,+ /// The runtime safely reported a probe failure.+ #[error("runtime model probe failed: {0}")]+ Runtime(String),+}+/// A bound session's queue. Only called just after inserting it.fn inbound_of(bound: &Bound, session: AgentSessionId) -> mpsc::Sender<ToServerMessage> {bounddiff --git a/crates/agent_session/src/domain/connection/test.rs b/crates/agent_session/src/domain/connection/test.rsindex 8a2e3bc41e..727809ab39 100644--- a/crates/agent_session/src/domain/connection/test.rs+++ b/crates/agent_session/src/domain/connection/test.rs@@ -4,7 +4,11 @@//! transcript, so "which session owns this" is a correctness question about//! that session's durable history.+use std::time::Duration;+use super::*;+use agent_runtime_protocol::domain::channel::Channel;+use agent_runtime_protocol::domain::schema::v0::ModelProbeResult;use agent_runtime_protocol::domain::schema::v0::SystemEvent;const OTHER: AgentSessionId = AgentSessionId::TEST_B;@@ -146,6 +150,20 @@ fn system_events_belong_to_the_connection() {assert_eq!(routes.route(&ready()), Routed::Connection);}+#[test]+fn model_probe_responses_belong_to_the_connection_waiters() {+ let mut routes = Routes::default();++ assert_eq!(+ routes.route(&ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Available {+ config_options: Vec::new(),+ },+ }),+ Routed::Probe+ );+}+#[test]fn a_finished_session_stops_owning_anything() {let mut routes = Routes::default();@@ -342,3 +360,127 @@ async fn a_resumed_session_owns_the_updates_that_follow() {Routed::Session(AgentSessionId::TEST_A));}++#[tokio::test]+async fn a_model_probe_answer_reaches_the_waiter_and_no_session() {+ let (carrier, mut runtime) = Channel::duplex();+ let connection = RuntimeConnection::connect(carrier);+ let attachment = connection.bind(AgentSessionId::TEST_A).await;+ let (_session_outbound, mut session_inbound) = attachment.connector.split();+ let probing = {+ let connection = Arc::clone(&connection);+ tokio::spawn(async move { connection.probe_models().await })+ };+ assert!(matches!(+ runtime.rx.recv().await,+ Some(ToRuntimeMessage::ModelProbeRequest)+ ));++ runtime+ .tx+ .send(ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Available {+ config_options: Vec::new(),+ },+ })+ .expect("response should send");++ assert!(+ probing+ .await+ .expect("probe task")+ .expect("the answer should succeed")+ .is_empty()+ );+ assert!(+ tokio::time::timeout(Duration::from_millis(20), session_inbound.recv())+ .await+ .is_err(),+ "probe responses must not be broadcast into a session transcript"+ );+}++/// Concurrent probes ask one parameterless question of one harness, so a+/// single answer is the truth for all of them.+#[tokio::test]+async fn one_model_probe_answer_serves_every_concurrent_waiter() {+ let (carrier, mut runtime) = Channel::duplex();+ let connection = RuntimeConnection::connect(carrier);+ let probes = (0..2)+ .map(|_| {+ let connection = Arc::clone(&connection);+ tokio::spawn(async move { connection.probe_models().await })+ })+ .collect::<Vec<_>>();+ for _ in 0..2 {+ assert!(matches!(+ runtime.rx.recv().await,+ Some(ToRuntimeMessage::ModelProbeRequest)+ ));+ }++ runtime+ .tx+ .send(ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Available {+ config_options: Vec::new(),+ },+ })+ .expect("response should send");++ for probe in probes {+ assert!(+ tokio::time::timeout(Duration::from_secs(1), probe)+ .await+ .expect("probe should not hang")+ .expect("probe task")+ .expect("the one answer should serve this waiter")+ .is_empty()+ );+ }+}++#[tokio::test]+async fn an_evicted_connection_stops_waiting_probes() {+ let (carrier, mut runtime) = Channel::duplex();+ let connection = RuntimeConnection::connect(carrier);+ let probing = {+ let connection = Arc::clone(&connection);+ tokio::spawn(async move { connection.probe_models().await })+ };+ assert!(matches!(+ runtime.rx.recv().await,+ Some(ToRuntimeMessage::ModelProbeRequest)+ ));++ connection.evict();++ assert!(matches!(+ tokio::time::timeout(Duration::from_secs(1), probing)+ .await+ .expect("an evicted probe should not hang")+ .expect("probe task"),+ Err(ModelProbeError::Closed)+ ));+}++#[tokio::test]+async fn pending_model_probe_ends_when_the_connection_closes() {+ let (carrier, mut runtime) = Channel::duplex();+ let connection = RuntimeConnection::connect(carrier);+ let probing = {+ let connection = Arc::clone(&connection);+ tokio::spawn(async move { connection.probe_models().await })+ };++ assert!(matches!(+ runtime.rx.recv().await,+ Some(ToRuntimeMessage::ModelProbeRequest)+ ));+ drop(runtime);++ assert!(matches!(+ probing.await.expect("probe task"),+ Err(ModelProbeError::Closed)+ ));+}diff --git a/crates/coding_agent_worker/src/daemon.rs b/crates/coding_agent_worker/src/daemon.rsindex 28cbde1cb9..ec3834ce14 100644--- a/crates/coding_agent_worker/src/daemon.rs+++ b/crates/coding_agent_worker/src/daemon.rs@@ -53,7 +53,12 @@ impl Daemon {let cancel = CancellationToken::new();let client = EventStreamClient::new(&config.macro_api, &credentials);let api = HarnessApi::new(&config.macro_api, &credentials);- let runtime = Runtime::new(&config.macro_api, &credentials, config.harness.clone());+ let runtime = Runtime::new(+ &config.macro_api,+ &credentials,+ config.harness.clone(),+ &config.workspace.path,+ );let executor = Dispatcher::new(api, runtime, config.workspace.clone());tracing::info!(diff --git a/crates/coding_agent_worker/src/harness.rs b/crates/coding_agent_worker/src/harness.rsindex f5b15391ca..1f12c1ecf2 100644--- a/crates/coding_agent_worker/src/harness.rs+++ b/crates/coding_agent_worker/src/harness.rs@@ -1,16 +1,22 @@//! The harness child process and the bridge between its stdio and the//! gateway channel.+use std::path::Path;+use std::time::Duration;+use crate::config::Harness;+use crate::outbound::acp_probe::{ProbeError, ProbeSubprocess, probe_subprocess};use agent_client_protocol::{AcpAgent, AcpAgentConfig, Client, ConnectTo};use agent_runtime_protocol::domain::connection::{- ConnectionError, RuntimeChannel, RuntimeConnection,+ ConnectionError, ModelProbeHandler, RuntimeChannel, RuntimeConnection,};use agent_runtime_protocol::domain::schema::v0::SystemEvent;#[cfg(test)]mod test;+const MODEL_PROBE_TIMEOUT: Duration = Duration::from_secs(10);+/// Why the bridge ended.#[derive(Debug, thiserror::Error)]pub enum BridgeError {@@ -23,8 +29,15 @@ pub enum BridgeError {}/// Spawn the harness in ACP mode and pump frames until either side ends.-pub async fn bridge(harness: &Harness, channel: RuntimeChannel) -> Result<(), BridgeError> {- let (runtime, acp) = RuntimeConnection::connect(channel);+pub async fn bridge(+ harness: &Harness,+ cwd: &Path,+ channel: RuntimeChannel,+) -> Result<(), BridgeError> {+ let probes = HarnessModelProbes {+ process: probe_process(harness, cwd),+ };+ let (runtime, acp) = RuntimeConnection::connect_with_model_probe_handler(channel, probes);let agent = AcpAgent::new(AcpAgentConfig::new(&harness.command).args(harness.args.clone()))// The wire tap: every ndjson line crossing the child's stdio, plus@@ -47,3 +60,38 @@ pub async fn bridge(harness: &Harness, channel: RuntimeChannel) -> Result<(), Broutcome.map_err(|error| BridgeError::Harness(error.to_string()))}++fn probe_process(harness: &Harness, cwd: &Path) -> ProbeSubprocess {+ ProbeSubprocess {+ command: harness.command.clone().into(),+ args: harness.args.clone(),+ cwd: cwd.to_owned(),+ }+}++#[derive(Clone)]+struct HarnessModelProbes {+ process: ProbeSubprocess,+}++impl ModelProbeHandler for HarnessModelProbes {+ async fn probe(+ &self,+ ) -> Result<Vec<agent_client_protocol::schema::v1::SessionConfigOption>, String> {+ probe_subprocess(&self.process, MODEL_PROBE_TIMEOUT)+ .await+ .map_err(safe_probe_error)+ }+}++fn safe_probe_error(error: ProbeError) -> String {+ match error {+ ProbeError::Timeout(_) => "the ACP model probe timed out".to_owned(),+ #[cfg(not(unix))]+ ProbeError::UnsupportedWorkingDirectory => {+ "the ACP model probe cannot apply the configured working directory".to_owned()+ }+ ProbeError::Protocol(_) => "the ACP model probe protocol failed".to_owned(),+ ProbeError::Process(_) => "the ACP model probe process failed".to_owned(),+ }+}diff --git a/crates/coding_agent_worker/src/harness/test.rs b/crates/coding_agent_worker/src/harness/test.rsindex 42dba96d2d..e664ba8a2a 100644--- a/crates/coding_agent_worker/src/harness/test.rs+++ b/crates/coding_agent_worker/src/harness/test.rs@@ -26,9 +26,13 @@ fn events(mut service: ServerChannel) -> Vec<SystemEvent> {async fn unspawnable_harness_reports_failure() {let (runtime, service) = Channel::duplex();- let error = bridge(&harness("macro-no-such-harness-binary"), runtime)- .await- .expect_err("a harness that cannot be spawned must not look like success");+ let error = bridge(+ &harness("macro-no-such-harness-binary"),+ std::path::Path::new("/"),+ runtime,+ )+ .await+ .expect_err("a harness that cannot be spawned must not look like success");assert!(matches!(error, BridgeError::Harness(_)), "got {error:?}");// The service is told the transport is done even though the child never@@ -45,7 +49,7 @@ async fn harness_that_exits_immediately_disconnects() {// `true` spawns cleanly and closes its stdio at once, which is the// shutdown path rather than the spawn-failure path above.- let _ = bridge(&harness("true"), runtime).await;+ let _ = bridge(&harness("true"), std::path::Path::new("/"), runtime).await;assert_eq!(events(service),@@ -60,9 +64,28 @@ async fn dropped_service_channel_does_not_panic_the_bridge() {// Announcing readiness into a closed channel is a failure to announce, not// a harness failure: nothing was ever spawned.- let error = bridge(&harness("true"), runtime)+ let error = bridge(&harness("true"), std::path::Path::new("/"), runtime).await.expect_err("announcing into a closed channel must fail");assert!(matches!(error, BridgeError::Announce(_)), "got {error:?}");}++#[tokio::test]+async fn model_probe_process_failures_are_safely_redacted() {+ let probes = HarnessModelProbes {+ process: ProbeSubprocess {+ command: "macro-no-such-harness-binary".into(),+ args: vec!["secret-argument".to_owned()],+ cwd: "/".into(),+ },+ };++ let error = probes+ .probe()+ .await+ .expect_err("unspawnable probe must fail");++ assert_eq!(error, "the ACP model probe process failed");+ assert!(!error.contains("secret-argument"));+}diff --git a/crates/coding_agent_worker/src/outbound/acp_probe.rs b/crates/coding_agent_worker/src/outbound/acp_probe.rsnew file mode 100644index 0000000000..7e422f222e--- /dev/null+++ b/crates/coding_agent_worker/src/outbound/acp_probe.rs@@ -0,0 +1,131 @@+//! Prompt-free inspection of a configured ACP subprocess.++use std::path::{Path, PathBuf};+use std::time::Duration;++use agent_client_protocol::schema::ProtocolVersion;+use agent_client_protocol::schema::v1::{+ InitializeRequest, NewSessionRequest, SessionConfigOption,+};+use agent_client_protocol::{AcpAgent, AcpAgentConfig, Agent, Channel, Client, ConnectionTo};++#[cfg(test)]+mod test;++/// A subprocess launch description for one isolated ACP probe.+#[derive(Clone, Debug, PartialEq, Eq)]+pub(crate) struct ProbeSubprocess {+ /// Executable or command name.+ pub(crate) command: PathBuf,+ /// Arguments passed to the executable.+ pub(crate) args: Vec<String>,+ /// Directory in which the executable runs.+ pub(crate) cwd: PathBuf,+}++/// A failure to discover an ACP agent's session configuration.+#[derive(Debug, thiserror::Error)]+#[non_exhaustive]+pub(crate) enum ProbeError {+ /// The initialize or session/new exchange failed.+ #[error("ACP model probe failed: {0}")]+ Protocol(String),+ /// The configured process stopped before the probe completed.+ #[error("ACP model probe process stopped: {0}")]+ Process(String),+ /// The bounded probe did not complete in time.+ #[error("ACP model probe timed out after {0:?}")]+ Timeout(Duration),+ /// This platform cannot apply a subprocess working directory while+ /// retaining `AcpAgent`'s process-group cleanup.+ #[cfg(not(unix))]+ #[error("ACP model probe working directories are unsupported on this platform")]+ UnsupportedWorkingDirectory,+}++/// Run `initialize` followed by `session/new` over an already-connected ACP+/// channel and return the new session's raw configuration options.+///+/// No prompt is sent. Dropping this future drops the ACP client connection.+async fn probe_channel(+ channel: Channel,+ cwd: &Path,+ deadline: Duration,+) -> Result<Vec<SessionConfigOption>, ProbeError> {+ let cwd = cwd.to_string_lossy().into_owned();+ let exchange = Client.connect_with(channel, async move |connection: ConnectionTo<Agent>| {+ connection+ .send_request(InitializeRequest::new(ProtocolVersion::V1))+ .block_task()+ .await?;+ let opened = connection+ .send_request(NewSessionRequest::new(cwd))+ .block_task()+ .await?;+ Ok(opened.config_options.unwrap_or_default())+ });++ tokio::time::timeout(deadline, exchange)+ .await+ .map_err(|_| ProbeError::Timeout(deadline))?+ .map_err(|error| ProbeError::Protocol(error.to_string()))+}++/// Spawn one configured ACP agent, perform a prompt-free model probe, and+/// tear down that exact child connection before returning.+///+/// On Unix the working directory is applied by a small `/bin/sh` wrapper+/// which immediately `exec`s the configured command. The wrapper and agent+/// remain in the process group guarded by [`AcpAgent`].+pub(crate) async fn probe_subprocess(+ process: &ProbeSubprocess,+ deadline: Duration,+) -> Result<Vec<SessionConfigOption>, ProbeError> {+ let expires = tokio::time::Instant::now() + deadline;+ let agent = subprocess_agent(process)?;+ let (channel, connection) =+ agent_client_protocol::ConnectTo::<Client>::into_channel_and_future(agent);+ let mut connection = std::pin::pin!(connection);+ let probe = std::pin::pin!(probe_channel(channel, &process.cwd, deadline));++ tokio::select! {+ // Prefer an already-observed child exit over its resulting ACP error.+ biased;+ result = &mut connection => match result {+ Ok(()) => Err(ProbeError::Process("process exited before responding".to_owned())),+ Err(error) => Err(ProbeError::Process(error.to_string())),+ },+ result = probe => {+ if matches!(result, Err(ProbeError::Protocol(_))) {+ // Stdio can close before the child-exit monitor resolves. Let+ // the SDK finish shutdown and collect the exit status before+ // classifying the failure, within the original probe deadline.+ if let Ok(Err(error)) = tokio::time::timeout_at(expires, connection).await {+ return Err(ProbeError::Process(error.to_string()));+ }+ }+ result+ },+ }+}++#[cfg(unix)]+fn subprocess_agent(process: &ProbeSubprocess) -> Result<AcpAgent, ProbeError> {+ // `$0` is a label, `$1` is cwd, and the remaining positional arguments+ // are the configured command and its arguments. No configured value is+ // interpolated into shell source.+ let mut args = vec![+ "-c".to_owned(),+ "cd -- \"$1\" && shift && exec \"$@\"".to_owned(),+ "acp-model-probe".to_owned(),+ process.cwd.to_string_lossy().into_owned(),+ process.command.to_string_lossy().into_owned(),+ ];+ args.extend(process.args.iter().cloned());+ Ok(AcpAgent::new(AcpAgentConfig::new("/bin/sh").args(args)))+}++#[cfg(not(unix))]+fn subprocess_agent(_process: &ProbeSubprocess) -> Result<AcpAgent, ProbeError> {+ Err(ProbeError::UnsupportedWorkingDirectory)+}diff --git a/crates/coding_agent_worker/src/outbound/acp_probe/test.rs b/crates/coding_agent_worker/src/outbound/acp_probe/test.rsnew file mode 100644index 0000000000..a40da30ddf--- /dev/null+++ b/crates/coding_agent_worker/src/outbound/acp_probe/test.rs@@ -0,0 +1,130 @@+use super::*;+use agent_client_protocol::Agent;+use agent_client_protocol::schema::v1::{+ InitializeResponse, NewSessionResponse, SessionConfigOption, SessionConfigSelectOption,+ SessionConfigValueId, SessionId,+};++fn model_options(current: &str) -> Vec<SessionConfigOption> {+ vec![SessionConfigOption::select(+ "model",+ "Model",+ SessionConfigValueId::new(current),+ vec![+ SessionConfigSelectOption::new(SessionConfigValueId::new("fast"), "Fast"),+ SessionConfigSelectOption::new(SessionConfigValueId::new("good"), "Good"),+ ],+ )]+}++#[tokio::test]+async fn connected_probe_initializes_and_opens_without_prompting() {+ let (client_channel, agent_channel) = Channel::duplex();+ let agent = tokio::spawn(+ Agent+ .builder()+ .on_receive_request(+ async |request: InitializeRequest, responder, _connection| {+ responder.respond(InitializeResponse::new(request.protocol_version))+ },+ agent_client_protocol::on_receive_request!(),+ )+ .on_receive_request(+ async |_: NewSessionRequest, responder, _connection| {+ responder.respond(+ NewSessionResponse::new(SessionId::new("probe"))+ .config_options(model_options("fast")),+ )+ },+ agent_client_protocol::on_receive_request!(),+ )+ .connect_to(agent_channel),+ );++ let options = probe_channel(+ client_channel,+ Path::new("/workspace"),+ Duration::from_secs(1),+ )+ .await+ .expect("probe should complete");++ assert_eq!(options, model_options("fast"));+ agent.abort();+}++#[tokio::test]+async fn connected_probe_is_bounded() {+ let (client_channel, _silent_peer) = Channel::duplex();++ let error = probe_channel(+ client_channel,+ Path::new("/workspace"),+ Duration::from_millis(10),+ )+ .await+ .expect_err("silent peer should time out");++ assert!(matches!(error, ProbeError::Timeout(_)));+}++#[cfg(unix)]+#[tokio::test]+async fn subprocess_probe_uses_configured_command_arguments_and_cwd() {+ let cwd = tempfile::tempdir().expect("temporary cwd");+ let script = r#"+import json, os, sys+initialize = json.loads(sys.stdin.readline())+print(json.dumps({"jsonrpc":"2.0","id":initialize["id"],"result":{+ "protocolVersion":1,"agentCapabilities":{}+}}), flush=True)+opening = json.loads(sys.stdin.readline())+assert opening["method"] == "session/new"+current = os.path.basename(os.getcwd()) + ":" + sys.argv[1]+print(json.dumps({"jsonrpc":"2.0","id":opening["id"],"result":{+ "sessionId":"probe",+ "configOptions":[{+ "id":"model","name":"Model","type":"select","currentValue":current,+ "options":[{"value":current,"name":current}]+ }]+}}), flush=True)+sys.stdin.read()+"#;+ let process = ProbeSubprocess {+ command: "python3".into(),+ args: vec!["-c".to_owned(), script.to_owned(), "argument".to_owned()],+ cwd: cwd.path().to_owned(),+ };++ let options = probe_subprocess(&process, Duration::from_secs(2))+ .await+ .expect("subprocess probe should complete");+ let encoded = serde_json::to_value(options).expect("options serialize");++ assert_eq!(+ encoded[0]["currentValue"],+ format!(+ "{}:argument",+ cwd.path().file_name().unwrap().to_string_lossy()+ )+ );+}++#[cfg(unix)]+#[tokio::test]+async fn subprocess_exit_after_stdio_closes_is_a_process_failure() {+ let process = ProbeSubprocess {+ command: "/bin/sh".into(),+ args: vec![+ "-c".to_owned(),+ "exec 1>&-; sleep 0.05; exit 127".to_owned(),+ ],+ cwd: "/".into(),+ };++ let error = probe_subprocess(&process, Duration::from_secs(2))+ .await+ .expect_err("a failing child cannot provide models");++ assert!(matches!(error, ProbeError::Process(_)), "got {error:?}");+}diff --git a/crates/coding_agent_worker/src/outbound/mod.rs b/crates/coding_agent_worker/src/outbound/mod.rsindex a43845f61b..1808351927 100644--- a/crates/coding_agent_worker/src/outbound/mod.rs+++ b/crates/coding_agent_worker/src/outbound/mod.rs@@ -6,6 +6,7 @@//! server-side field rename becomes a compile error on this side instead of a//! runtime surprise on someone's laptop.+pub(crate) mod acp_probe;pub mod agent_session;pub mod link;pub mod pairing;diff --git a/crates/coding_agent_worker/src/runtime.rs b/crates/coding_agent_worker/src/runtime.rsindex 10c51e86f3..efdc798a5d 100644--- a/crates/coding_agent_worker/src/runtime.rs+++ b/crates/coding_agent_worker/src/runtime.rs@@ -11,6 +11,7 @@//! What that buys: a harness starts once per daemon rather than once per//! session, so only the first mention after boot pays for a cold agent.+use std::path::{Path, PathBuf};use std::sync::Arc;use std::sync::atomic::{AtomicBool, Ordering};use std::time::Duration;@@ -45,17 +46,24 @@ pub struct Runtime {gateway_url: String,token: String,harness: Harness,+ cwd: PathBuf,live: Arc<AtomicBool>,}impl Runtime {/// A runtime that dials with the given credentials and spawns the given/// harness.- pub fn new(macro_api: &MacroApi, credentials: &HarnessCredentials, harness: Harness) -> Self {+ pub fn new(+ macro_api: &MacroApi,+ credentials: &HarnessCredentials,+ harness: Harness,+ cwd: &Path,+ ) -> Self {Self {gateway_url: macro_api.gateway_url(),token: credentials.token.clone(),harness,+ cwd: cwd.to_owned(),live: Arc::new(AtomicBool::new(false)),}}@@ -85,6 +93,7 @@ impl Runtime {channel,self.token.clone(),self.harness.clone(),+ self.cwd.clone(),Arc::clone(&self.live),));Ok(())@@ -100,16 +109,17 @@ async fn serve(channel: RuntimeChannel,token: String,harness: Harness,+ cwd: PathBuf,live: Arc<AtomicBool>,) {tracing::info!("harness bridge starting");// A bridge that ends cleanly is a runtime that is done being asked for// anything; the next delivery dials again.- match harness::bridge(&harness, channel).await {+ match harness::bridge(&harness, &cwd, channel).await {Ok(()) => tracing::info!("harness bridge ended"),Err(error) => {tracing::warn!(error = ?error, "harness bridge ended with an error");- rebuild(&gateway_url, &token, &harness).await;+ rebuild(&gateway_url, &token, &harness, &cwd).await;}}live.store(false, Ordering::Release);@@ -117,7 +127,7 @@ async fn serve(/// Dial and serve again, as one retried operation: ending cleanly stops it, as/// does a gateway verdict no retry can change.-async fn rebuild(gateway_url: &str, token: &str, harness: &Harness) {+async fn rebuild(gateway_url: &str, token: &str, harness: &Harness, cwd: &Path) {let outcome = RetryIf::start(rebuild_strategy(),|| async {@@ -125,7 +135,7 @@ async fn rebuild(gateway_url: &str, token: &str, harness: &Harness) {.await.map_err(ServeError::Dial)?;tracing::info!("harness bridge restarting");- harness::bridge(harness, channel)+ harness::bridge(harness, cwd, channel).await.map_err(ServeError::Bridge)},diff --git a/crates/cursor_cloud_agents/src/domain/mod.rs b/crates/cursor_cloud_agents/src/domain/mod.rsindex 982892f423..69b769e0cc 100644--- a/crates/cursor_cloud_agents/src/domain/mod.rs+++ b/crates/cursor_cloud_agents/src/domain/mod.rs@@ -8,6 +8,8 @@ pub mod event;/// Identifiers and small value types.pub mod model;+/// Cursor model catalog expressed as ACP configuration.+pub mod model_options;/// The capabilities the domain requires from the outside.pub mod ports;diff --git a/crates/cursor_cloud_agents/src/domain/model_options.rs b/crates/cursor_cloud_agents/src/domain/model_options.rsnew file mode 100644index 0000000000..d21f853992--- /dev/null+++ b/crates/cursor_cloud_agents/src/domain/model_options.rs@@ -0,0 +1,62 @@+//! Shared projection of Cursor's model catalog into ACP session configuration.++use super::model::{CursorModel, ModelFamily};+use agent_client_protocol::schema::v1::{+ SessionConfigGroupId, SessionConfigId, SessionConfigKind, SessionConfigOption,+ SessionConfigSelect, SessionConfigSelectGroup, SessionConfigSelectOption,+ SessionConfigSelectOptions, SessionConfigValueId,+};++/// ACP config id used for model selection.+pub const MODEL_CONFIG_ID: &str = "model";++/// Cursor's server-selected model entry.+pub const AUTO_MODEL_ID: &str = "default";++/// Build the same model select advertised by Cursor ACP sessions.+#[must_use]+pub fn cursor_model_config_options(+ models: &[CursorModel],+ current: Option<String>,+) -> Vec<SessionConfigOption> {+ let current = current.or_else(|| {+ models+ .iter()+ .find(|model| model.id == AUTO_MODEL_ID)+ .map(|model| model.id.clone())+ });+ let Some(current) = current else {+ return Vec::new();+ };+ let select_option = |model: &CursorModel| {+ SessionConfigSelectOption::new(+ SessionConfigValueId::new(model.id.clone()),+ model.display_name.clone(),+ )+ };+ let families = ModelFamily::group(models);+ let options = if ModelFamily::is_informative(&families) {+ SessionConfigSelectOptions::Grouped(+ families+ .iter()+ .map(|family| {+ SessionConfigSelectGroup::new(+ SessionConfigGroupId::new(family.id.clone()),+ family.name.clone(),+ family.models.iter().map(select_option).collect(),+ )+ })+ .collect(),+ )+ } else {+ SessionConfigSelectOptions::Ungrouped(models.iter().map(select_option).collect())+ };+ vec![SessionConfigOption::new(+ SessionConfigId::new(MODEL_CONFIG_ID),+ "Model",+ SessionConfigKind::Select(SessionConfigSelect::new(+ SessionConfigValueId::new(current),+ options,+ )),+ )]+}diff --git a/crates/cursor_cloud_agents/src/inbound/acp.rs b/crates/cursor_cloud_agents/src/inbound/acp.rsindex 6ea39b9c52..362043d64b 100644--- a/crates/cursor_cloud_agents/src/inbound/acp.rs+++ b/crates/cursor_cloud_agents/src/inbound/acp.rs@@ -28,7 +28,8 @@#[cfg(test)]mod test;-use crate::domain::model::{McpHeader, McpServer, McpTransport, ModelFamily};+use crate::domain::model::{McpHeader, McpServer, McpTransport};+use crate::domain::model_options::{MODEL_CONFIG_ID, cursor_model_config_options};use crate::domain::ports::{CursorAgents, RepoResolver, RunStream, SessionNotifier};use crate::domain::service::CursorSessionService;use agent_client_protocol::schema::ProtocolVersion;@@ -37,11 +38,9 @@ use agent_client_protocol::schema::v1::{CloseSessionRequest, CloseSessionResponse, ContentBlock, ContentChunk, Error as AcpError,HttpHeader, Implementation, InitializeRequest, InitializeResponse, LoadSessionRequest,LoadSessionResponse, McpCapabilities, McpServer as AcpMcpServer, Meta, NewSessionRequest,- NewSessionResponse, PromptCapabilities, PromptRequest, PromptResponse, SessionConfigGroupId,- SessionConfigId, SessionConfigKind, SessionConfigOption, SessionConfigSelect,- SessionConfigSelectGroup, SessionConfigSelectOption, SessionConfigSelectOptions,- SessionConfigValueId, SessionId, SessionNotification, SessionUpdate,- SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, TextContent,+ NewSessionResponse, PromptCapabilities, PromptRequest, PromptResponse, SessionConfigOption,+ SessionId, SessionNotification, SessionUpdate, SetSessionConfigOptionRequest,+ SetSessionConfigOptionResponse, TextContent,};use agent_client_protocol::{Agent, ByteStreams, Client, ConnectTo, ConnectionTo, on_receive_notification,@@ -50,19 +49,6 @@ use agent_client_protocol::{use std::sync::{Arc, OnceLock};use tokio_util::compat::{TokioAsyncReadCompatExt as _, TokioAsyncWriteCompatExt as _};-/// The ACP config-option id for a session's model.-///-/// Defined here rather than shared with the Macro harness: this crate is a-/// standalone ACP agent (see the `cursor_cloud_agents` binary) and must not-/// depend on its embedder. `"model"` is the id every ACP client looks for, and-/// the harness uses the same literal for the same reason.-const MODEL_CONFIG_ID: &str = "model";--/// Cursor's own "let the server pick" model (`GET /v1/models` lists it as-/// `default`, displayed "Auto") — the select's resting value when nothing has-/// been chosen.-const AUTO_MODEL_ID: &str = "default";-/// Delivers session updates as `session/update` notifications on the ACP/// connection.///@@ -570,46 +556,7 @@ where//// If Cursor ever drops the entry there is no honest resting value, and no// picker beats one resting on a guess.- let current = current.or_else(|| {- models- .iter()- .find(|model| model.id == AUTO_MODEL_ID)- .map(|model| model.id.clone())- });- let Some(current) = current else {- return Vec::new();- };- let select_option = |model: &crate::domain::model::CursorModel| {- SessionConfigSelectOption::new(- SessionConfigValueId::new(model.id.clone()),- model.display_name.clone(),- )- };- let families = ModelFamily::group(&models);- let options = if ModelFamily::is_informative(&families) {- SessionConfigSelectOptions::Grouped(- families- .iter()- .map(|family| {- SessionConfigSelectGroup::new(- SessionConfigGroupId::new(family.id.clone()),- family.name.clone(),- family.models.iter().map(select_option).collect(),- )- })- .collect(),- )- } else {- SessionConfigSelectOptions::Ungrouped(models.iter().map(select_option).collect())- };- vec![SessionConfigOption::new(- SessionConfigId::new(MODEL_CONFIG_ID),- "Model",- SessionConfigKind::Select(SessionConfigSelect::new(- SessionConfigValueId::new(current),- options,- )),- )]+ cursor_model_config_options(&models, current)}/// Concatenate a prompt's content blocks into the single string Cursor takes.diff --git a/crates/harnesses/Cargo.toml b/crates/harnesses/Cargo.tomlindex c08025b70a..ea92dd75c0 100644--- a/crates/harnesses/Cargo.toml+++ b/crates/harnesses/Cargo.toml@@ -44,5 +44,4 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" }[dev-dependencies]harness_id = { path = "../harness_id", features = ["test-utils"] }macro_db_migrator = { path = "../macro_db_migrator" }-serde_json = { workspace = true }tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }diff --git a/crates/harnesses/src/outbound/pg_harness_repo/tests.rs b/crates/harnesses/src/outbound/pg_harness_repo/tests.rsindex 83bbf12dfc..aa8e54aaaf 100644--- a/crates/harnesses/src/outbound/pg_harness_repo/tests.rs+++ b/crates/harnesses/src/outbound/pg_harness_repo/tests.rs@@ -79,7 +79,6 @@ async fn pairing_walks_create_approve_claim_exactly_once(pool: PgPool) {row.details.requested_scope,Some(RequestedHarnessScope::Team));-let harness = repo.approve_pairing("KX7M-4QHD", new_harness()).awaitdiff --git a/docs/AGENT_GUIDE/surfaces.md b/docs/AGENT_GUIDE/surfaces.mdindex 5aba981f61..9af3fe2dfe 100644--- a/docs/AGENT_GUIDE/surfaces.md+++ b/docs/AGENT_GUIDE/surfaces.md@@ -164,7 +164,7 @@ list / delete personal keys; the secret is shown only once and is sent as`x-macro-user-api-key`), `Notifications`, `Billing`,`Appearance`, `Mobile App`, `Shortcuts` (interactive keyboard visualization, not a list);Workspace → `Team`, `Tags`, `CRM`, `Connections` (email/tool OAuth), `MCP server`-(setup snippets for Claude Code / Codex CLI / Claude.ai / ChatGPT / IDE), `Agents`, `Bots`;+(setup snippets for Claude Code / Codex CLI / Claude.ai / ChatGPT / IDE), `Agents`, `Bots`, `Harness`;`Log out`.`Agents` lists team and private agents with `Create agent` / `Edit <name>` dialogs groupedProfile, Behavior, Runtime, Connections, Channels, Share. Connections is a radio pair:@@ -178,6 +178,16 @@ but unconnected app gets a tool result saying so, and the agent's reply renders`Connect <app>` chip that opens Settings → Connections for that app.`Back to app` returns to the previous surface. Open via user-email button menu or `Ctrl+;`.+`Agents` → `Create agent` (or edit an existing agent) opens runtime selectors.+The model list is loaded live and independently for In-memory, connected Cursor, and every+registered macrod harness. A harness can show `Loading models…`, an unsupported message, or+a retryable error without hiding the other harnesses. Editing preserves a saved model that+is no longer offered and labels it `saved, unavailable`. A macrod with no responding runtime+can remain loading until the 10-second discovery timeout; use Retry after reconnecting it.++`Harness` configures Cursor and paired macrod runtimes. Cursor's default-model picker uses+the same live model discovery and retains its existing save action.+## NotificationsToast regions are labeled `Notifications (alt+T)`; five empty live regions always exist indiff --git a/packages/sdk/generated/agent-harness/index.ts b/packages/sdk/generated/agent-harness/index.tsindex ce9a2581bb..59d545ba29 100644--- a/packages/sdk/generated/agent-harness/index.ts+++ b/packages/sdk/generated/agent-harness/index.ts@@ -1,4 +1,4 @@// This file is auto-generated by @hey-api/openapi-tsexport { type Options, Sdk } from './sdk.gen';-export type { AgentAction, AgentActionId, AgentPromptAction, AgentRespondElicitationAction, AgentSessionLogEntryDto, AgentSessionLogResponse, AgentSessionQueueResponse, AgentSessionResponse, AgentSetModelAction, BotId, ClientOptions, ControlAgentSessionData, ControlAgentSessionError, ControlAgentSessionErrors, ControlAgentSessionResponse, ControlAgentSessionResponses, ControlRequest, ControlResponse, ControlStatusDto, CreateAgentSessionData, CreateAgentSessionError, CreateAgentSessionErrors, CreateAgentSessionRequest, CreateAgentSessionResponse, CreateAgentSessionResponse2, CreateAgentSessionResponses, CreateSessionThread, DeleteAgentSessionData, DeleteAgentSessionError, DeleteAgentSessionErrors, DeleteAgentSessionResponses, EditQueuedActionData, EditQueuedActionError, EditQueuedActionErrors, EditQueuedActionRequest, EditQueuedActionResponse, EditQueuedActionResponses, ElicitationAnswer, ElicitationContentValue, ElicitationRequestId, ExternalSessionResponse, GetAgentSandboxSizeData, GetAgentSandboxSizeError, GetAgentSandboxSizeErrors, GetAgentSandboxSizeResponse, GetAgentSandboxSizeResponses, GetAgentSessionData, GetAgentSessionError, GetAgentSessionErrors, GetAgentSessionLogData, GetAgentSessionLogError, GetAgentSessionLogErrors, GetAgentSessionLogResponse, GetAgentSessionLogResponses, GetAgentSessionQueueData, GetAgentSessionQueueError, GetAgentSessionQueueErrors, GetAgentSessionQueueResponse, GetAgentSessionQueueResponses, GetAgentSessionResponse, GetAgentSessionResponses, LogDirectionDto, LogFrameDto, PutAgentSandboxSizeData, PutAgentSandboxSizeError, PutAgentSandboxSizeErrors, PutAgentSandboxSizeResponse, PutAgentSandboxSizeResponses, PutAgentSessionSandboxSizeData, PutAgentSessionSandboxSizeError, PutAgentSessionSandboxSizeErrors, PutAgentSessionSandboxSizeResponse, PutAgentSessionSandboxSizeResponses, QueuedActionDto, RemoveQueuedActionData, RemoveQueuedActionError, RemoveQueuedActionErrors, RemoveQueuedActionResponse, RemoveQueuedActionResponses, RenameAgentSessionData, RenameAgentSessionError, RenameAgentSessionErrors, RenameAgentSessionRequest, RenameAgentSessionResponse, RenameAgentSessionResponses, SandboxSize, SandboxSizeBody, SessionBot, SessionStatusDto } from './types.gen';+export type { AgentAction, AgentActionId, AgentModelDto, AgentModelsStatusDto, AgentPromptAction, AgentRespondElicitationAction, AgentSessionLogEntryDto, AgentSessionLogResponse, AgentSessionQueueResponse, AgentSessionResponse, AgentSetModelAction, BotId, ClientOptions, ControlAgentSessionData, ControlAgentSessionError, ControlAgentSessionErrors, ControlAgentSessionResponse, ControlAgentSessionResponses, ControlRequest, ControlResponse, ControlStatusDto, CreateAgentSessionData, CreateAgentSessionError, CreateAgentSessionErrors, CreateAgentSessionRequest, CreateAgentSessionResponse, CreateAgentSessionResponse2, CreateAgentSessionResponses, CreateSessionThread, DeleteAgentSessionData, DeleteAgentSessionError, DeleteAgentSessionErrors, DeleteAgentSessionResponses, EditQueuedActionData, EditQueuedActionError, EditQueuedActionErrors, EditQueuedActionRequest, EditQueuedActionResponse, EditQueuedActionResponses, ElicitationAnswer, ElicitationContentValue, ElicitationRequestId, ExternalSessionResponse, GetAgentSandboxSizeData, GetAgentSandboxSizeError, GetAgentSandboxSizeErrors, GetAgentSandboxSizeResponse, GetAgentSandboxSizeResponses, GetAgentSessionData, GetAgentSessionError, GetAgentSessionErrors, GetAgentSessionLogData, GetAgentSessionLogError, GetAgentSessionLogErrors, GetAgentSessionLogResponse, GetAgentSessionLogResponses, GetAgentSessionQueueData, GetAgentSessionQueueError, GetAgentSessionQueueErrors, GetAgentSessionQueueResponse, GetAgentSessionQueueResponses, GetAgentSessionResponse, GetAgentSessionResponses, LoadAgentModelsHandlerData, LoadAgentModelsHandlerErrors, LoadAgentModelsHandlerResponse, LoadAgentModelsHandlerResponses, LoadAgentModelsRequest, LoadAgentModelsResponse, LogDirectionDto, LogFrameDto, ModelHarnessDto, PutAgentSandboxSizeData, PutAgentSandboxSizeError, PutAgentSandboxSizeErrors, PutAgentSandboxSizeResponse, PutAgentSandboxSizeResponses, PutAgentSessionSandboxSizeData, PutAgentSessionSandboxSizeError, PutAgentSessionSandboxSizeErrors, PutAgentSessionSandboxSizeResponse, PutAgentSessionSandboxSizeResponses, QueuedActionDto, RemoveQueuedActionData, RemoveQueuedActionError, RemoveQueuedActionErrors, RemoveQueuedActionResponse, RemoveQueuedActionResponses, RenameAgentSessionData, RenameAgentSessionError, RenameAgentSessionErrors, RenameAgentSessionRequest, RenameAgentSessionResponse, RenameAgentSessionResponses, SandboxSize, SandboxSizeBody, SessionBot, SessionStatusDto } from './types.gen';diff --git a/packages/sdk/generated/agent-harness/sdk.gen.ts b/packages/sdk/generated/agent-harness/sdk.gen.tsindex ae78fdd4a5..80d76466e0 100644--- a/packages/sdk/generated/agent-harness/sdk.gen.ts+++ b/packages/sdk/generated/agent-harness/sdk.gen.ts@@ -2,7 +2,7 @@import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client';import { client } from './client.gen';-import type { ControlAgentSessionData, ControlAgentSessionErrors, ControlAgentSessionResponses, CreateAgentSessionData, CreateAgentSessionErrors, CreateAgentSessionResponses, DeleteAgentSessionData, DeleteAgentSessionErrors, DeleteAgentSessionResponses, EditQueuedActionData, EditQueuedActionErrors, EditQueuedActionResponses, GetAgentSandboxSizeData, GetAgentSandboxSizeErrors, GetAgentSandboxSizeResponses, GetAgentSessionData, GetAgentSessionErrors, GetAgentSessionLogData, GetAgentSessionLogErrors, GetAgentSessionLogResponses, GetAgentSessionQueueData, GetAgentSessionQueueErrors, GetAgentSessionQueueResponses, GetAgentSessionResponses, PutAgentSandboxSizeData, PutAgentSandboxSizeErrors, PutAgentSandboxSizeResponses, PutAgentSessionSandboxSizeData, PutAgentSessionSandboxSizeErrors, PutAgentSessionSandboxSizeResponses, RemoveQueuedActionData, RemoveQueuedActionErrors, RemoveQueuedActionResponses, RenameAgentSessionData, RenameAgentSessionErrors, RenameAgentSessionResponses } from './types.gen';+import type { ControlAgentSessionData, ControlAgentSessionErrors, ControlAgentSessionResponses, CreateAgentSessionData, CreateAgentSessionErrors, CreateAgentSessionResponses, DeleteAgentSessionData, DeleteAgentSessionErrors, DeleteAgentSessionResponses, EditQueuedActionData, EditQueuedActionErrors, EditQueuedActionResponses, GetAgentSandboxSizeData, GetAgentSandboxSizeErrors, GetAgentSandboxSizeResponses, GetAgentSessionData, GetAgentSessionErrors, GetAgentSessionLogData, GetAgentSessionLogErrors, GetAgentSessionLogResponses, GetAgentSessionQueueData, GetAgentSessionQueueErrors, GetAgentSessionQueueResponses, GetAgentSessionResponses, LoadAgentModelsHandlerData, LoadAgentModelsHandlerErrors, LoadAgentModelsHandlerResponses, PutAgentSandboxSizeData, PutAgentSandboxSizeErrors, PutAgentSandboxSizeResponses, PutAgentSessionSandboxSizeData, PutAgentSessionSandboxSizeErrors, PutAgentSessionSandboxSizeResponses, RemoveQueuedActionData, RemoveQueuedActionErrors, RemoveQueuedActionResponses, RenameAgentSessionData, RenameAgentSessionErrors, RenameAgentSessionResponses } from './types.gen';export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {/**@@ -57,6 +57,21 @@ export class Sdk extends HeyApiClient {Sdk.__registry.set(this, args?.key);}+ /**+ * Probe one provider's model catalog without creating an agent session.+ */+ public loadAgentModelsHandler<ThrowOnError extends boolean = false>(options: Options<LoadAgentModelsHandlerData, ThrowOnError>): RequestResult<LoadAgentModelsHandlerResponses, LoadAgentModelsHandlerErrors, ThrowOnError> {+ return (options.client ?? this.client).post<LoadAgentModelsHandlerResponses, LoadAgentModelsHandlerErrors, ThrowOnError>({+ security: [{ scheme: 'bearer', type: 'http' }],+ url: '/agent-models/load',+ ...options,+ headers: {+ 'Content-Type': 'application/json',+ ...options.headers+ }+ });+ }+/*** Read the caller's default sandbox size for new `@coder` sessions.*/diff --git a/packages/sdk/generated/agent-harness/types.gen.ts b/packages/sdk/generated/agent-harness/types.gen.tsindex 5f1ede72c7..af38cf4f8c 100644--- a/packages/sdk/generated/agent-harness/types.gen.ts+++ b/packages/sdk/generated/agent-harness/types.gen.ts@@ -33,6 +33,33 @@ export type AgentAction = (AgentPromptAction & {*/export type AgentActionId = string;+/**+ * One model picker option.+ */+export type AgentModelDto = {+ /**+ * Optional provider description.+ */+ description?: string | null;+ /**+ * Optional group heading supplied by the provider.+ */+ group?: string | null;+ /**+ * Provider model id.+ */+ id: string;+ /**+ * Display name.+ */+ name: string;+};++/**+ * Model-selection availability returned over HTTP.+ */+export type AgentModelsStatusDto = 'available' | 'unsupported';+/*** Ask the agent to work on something.*/@@ -418,6 +445,38 @@ export type ExternalSessionResponse = {url?: string | null;};+/**+ * HTTP request selecting one provider to probe.+ */+export type LoadAgentModelsRequest = {+ /**+ * Provider to probe.+ */+ harness: ModelHarnessDto;+ /**+ * Required for macrod and forbidden for other targets.+ */+ harnessId?: string | null;+};++/**+ * Successful model-discovery response.+ */+export type LoadAgentModelsResponse = {+ /**+ * Current provider model, if model selection is available.+ */+ currentModel?: string | null;+ /**+ * Ordered model catalog.+ */+ models: Array<AgentModelDto>;+ /**+ * Model-selection availability.+ */+ status: AgentModelsStatusDto;+};+/*** Which way a logged frame travelled, mirroring [`Message`]'s discriminant.*/@@ -446,6 +505,11 @@ export type LogFrameDto = {direction: LogDirectionDto;};+/**+ * Harness names accepted by the model discovery endpoint.+ */+export type ModelHarnessDto = 'in-memory' | 'cursor' | 'macrod';+/*** One action waiting in a session's queue.*@@ -538,6 +602,49 @@ export type SessionStatusDto = {kind: 'disconnected';};+export type LoadAgentModelsHandlerData = {+ body: LoadAgentModelsRequest;+ path?: never;+ query?: never;+ url: '/agent-models/load';+};++export type LoadAgentModelsHandlerErrors = {+ /**+ * Invalid target+ */+ 400: unknown;+ /**+ * Unauthenticated+ */+ 401: unknown;+ /**+ * Harness is not visible to caller+ */+ 403: unknown;+ /**+ * Macrod runtime is disconnected+ */+ 409: unknown;+ /**+ * Provider probe failed+ */+ 502: unknown;+ /**+ * Macrod probe timed out+ */+ 504: unknown;+};++export type LoadAgentModelsHandlerResponses = {+ /**+ * Fresh provider model catalog+ */+ 200: LoadAgentModelsResponse;+};++export type LoadAgentModelsHandlerResponse = LoadAgentModelsHandlerResponses[keyof LoadAgentModelsHandlerResponses];+export type GetAgentSandboxSizeData = {body?: never;path?: never;diff --git a/packages/sdk/specs/agent-harness.json b/packages/sdk/specs/agent-harness.jsonindex 9b337e6f15..9f079d8c48 100644--- a/packages/sdk/specs/agent-harness.json+++ b/packages/sdk/specs/agent-harness.json@@ -10,6 +10,58 @@"version": "0.1.0"},"paths": {+ "/agent-models/load": {+ "post": {+ "tags": ["agent-models"],+ "summary": "Probe one provider's model catalog without creating an agent session.",+ "operationId": "load_agent_models_handler",+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/LoadAgentModelsRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "Fresh provider model catalog",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/LoadAgentModelsResponse"+ }+ }+ }+ },+ "400": {+ "description": "Invalid target"+ },+ "401": {+ "description": "Unauthenticated"+ },+ "403": {+ "description": "Harness is not visible to caller"+ },+ "409": {+ "description": "Macrod runtime is disconnected"+ },+ "502": {+ "description": "Provider probe failed"+ },+ "504": {+ "description": "Macrod probe timed out"+ }+ },+ "security": [+ {+ "bearerAuth": []+ }+ ]+ }+ },"/agent-sandbox-size": {"get": {"tags": ["agent-sessions"],@@ -897,6 +949,34 @@"format": "uuid","description": "Identifies one accepted [`AgentAction`] end to end: returned by the\ncontrol endpoint, written as the JSON-RPC request id on the action's wire\nframe, and read back off that frame as `request_id` on the folded message\nit derives.\n\nMinted only by the server at accept time, as a v7 uuid so ids sort by mint\ntime. On the wire and in JSON it is the bare uuid, and a uuid-shaped\nrequest id is the whole ownership test: the server is the only writer of\nruntime-bound frames. The machine's own handshake request ids\n(`agent_session:{session}:{n}`) are not uuids and stay `None`."},+ "AgentModelDto": {+ "type": "object",+ "description": "One model picker option.",+ "required": ["id", "name"],+ "properties": {+ "description": {+ "type": ["string", "null"],+ "description": "Optional provider description."+ },+ "group": {+ "type": ["string", "null"],+ "description": "Optional group heading supplied by the provider."+ },+ "id": {+ "type": "string",+ "description": "Provider model id."+ },+ "name": {+ "type": "string",+ "description": "Display name."+ }+ }+ },+ "AgentModelsStatusDto": {+ "type": "string",+ "description": "Model-selection availability returned over HTTP.",+ "enum": ["available", "unsupported"]+ },"AgentPromptAction": {"type": "object","description": "Ask the agent to work on something.",@@ -1338,6 +1418,44 @@}}},+ "LoadAgentModelsRequest": {+ "type": "object",+ "description": "HTTP request selecting one provider to probe.",+ "required": ["harness"],+ "properties": {+ "harness": {+ "$ref": "#/components/schemas/ModelHarnessDto",+ "description": "Provider to probe."+ },+ "harnessId": {+ "type": ["string", "null"],+ "format": "uuid",+ "description": "Required for macrod and forbidden for other targets."+ }+ }+ },+ "LoadAgentModelsResponse": {+ "type": "object",+ "description": "Successful model-discovery response.",+ "required": ["status", "models"],+ "properties": {+ "currentModel": {+ "type": ["string", "null"],+ "description": "Current provider model, if model selection is available."+ },+ "models": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/AgentModelDto"+ },+ "description": "Ordered model catalog."+ },+ "status": {+ "$ref": "#/components/schemas/AgentModelsStatusDto",+ "description": "Model-selection availability."+ }+ }+ },"LogDirectionDto": {"type": "string","description": "Which way a logged frame travelled, mirroring [`Message`]'s discriminant.",@@ -1358,6 +1476,11 @@}}},+ "ModelHarnessDto": {+ "type": "string",+ "description": "Harness names accepted by the model discovery endpoint.",+ "enum": ["in-memory", "cursor", "macrod"]+ },"QueuedActionDto": {"type": "object","description": "One action waiting in a session's queue.\n\nClients deserialize this, so both derives are used.",@@ -1474,12 +1597,22 @@],"description": "Transport representation of a session's status, mirroring\n[`SessionStatus`]."}+ },+ "securitySchemes": {+ "bearerAuth": {+ "type": "http",+ "scheme": "bearer"+ }}},"tags": [{"name": "agent-sessions","description": "Agent sessions"+ },+ {+ "name": "agent-models",+ "description": "Fresh provider model discovery"}]}diff --git a/packages/sdk/src/coverage/skipped.ts b/packages/sdk/src/coverage/skipped.tsindex fff2ee79e6..14a287509f 100644--- a/packages/sdk/src/coverage/skipped.ts+++ b/packages/sdk/src/coverage/skipped.ts@@ -23,8 +23,9 @@ import type { Sdk as StaticFilesSdk } from '../../generated/static-files/sdk.genimport type { Sdk as StorageSdk } from '../../generated/storage/sdk.gen';import type { Sdk as UnfurlSdk } from '../../generated/unfurl/sdk.gen';-export const agentHarnessExcluded =- [] as const satisfies readonly (keyof AgentHarnessSdk)[];+export const agentHarnessExcluded = [+ 'loadAgentModelsHandler',+] as const satisfies readonly (keyof AgentHarnessSdk)[];export const agentHarnessBacklog =[] as const satisfies readonly (keyof AgentHarnessSdk)[];diff --git a/services/agent_harness_service/Cargo.toml b/services/agent_harness_service/Cargo.tomlindex 8512f80b65..7218ba62c4 100644--- a/services/agent_harness_service/Cargo.toml+++ b/services/agent_harness_service/Cargo.toml@@ -30,6 +30,7 @@ aws-sdk-sqs = { workspace = true }bot_id = { path = "../../crates/bot_id" }bots = { path = "../../crates/bots" }harness_id = { path = "../../crates/harness_id" }+harnesses = { path = "../../crates/harnesses", default-features = false, features = ["outbound", "ports"] }connection_gateway_client = { path = "../../crates/connection_gateway_client" }aws-sdk-kms = { workspace = true }cursor_api_key = { path = "../../crates/cursor_api_key" }@@ -88,4 +89,6 @@ tracing = { workspace = true }workspace-hack = { version = "0.1", path = "../../crates/workspace-hack" }[dev-dependencies]+agent-client-protocol = { workspace = true }agent_session = { path = "../../crates/agent_session", features = ["test-utils"] }+harness_id = { path = "../../crates/harness_id", features = ["test-utils"] }diff --git a/services/agent_harness_service/src/api.rs b/services/agent_harness_service/src/api.rsindex a8edbdf3ac..0d0e58588a 100644--- a/services/agent_harness_service/src/api.rs+++ b/services/agent_harness_service/src/api.rs@@ -7,6 +7,8 @@ use std::time::Duration;use agent_egress::domain::service::EgressService;use agent_egress::inbound::axum_router::{EgressRouterState, egress_router};+use agent_harness::domain::model_load::AgentModelsService;+use agent_harness::inbound::model_load::{AgentModelsRouterState, agent_models_router};use agent_harness::inbound::runtime_gateway::{RuntimeGatewayState, runtime_gateway_router};use agent_session::domain::ports::{AgentSessionNotificationRecipient, BotDirectory, SessionOpener,@@ -53,6 +55,34 @@ fn health_router(ready: tokio::sync::watch::Receiver<bool>) -> Router {Router::new().route("/health", get(health).with_state(ready))}+/// All route state served by the public agent-harness HTTP listener.+pub struct ApiStates<T, R, Opener, Bots, Access, Auth, Models> {+ read: AgentSessionRouterState<T, Access, Auth>,+ control: AgentSessionControlState<R, Access, Auth>,+ create: CreateSessionState<Opener, Bots, Auth>,+ gateway: RuntimeGatewayState<Auth>,+ models: AgentModelsRouterState<Models, Auth>,+}++impl<T, R, Opener, Bots, Access, Auth, Models> ApiStates<T, R, Opener, Bots, Access, Auth, Models> {+ /// Group the independently constructed route states for the HTTP server.+ pub fn new(+ read: AgentSessionRouterState<T, Access, Auth>,+ control: AgentSessionControlState<R, Access, Auth>,+ create: CreateSessionState<Opener, Bots, Auth>,+ gateway: RuntimeGatewayState<Auth>,+ models: AgentModelsRouterState<Models, Auth>,+ ) -> Self {+ Self {+ read,+ control,+ create,+ gateway,+ models,+ }+ }+}+/// Serve the sandbox-facing egress proxy on its own listener.////// No CORS layer and no Swagger: nothing browses this. Its only client is a@@ -80,11 +110,8 @@ where}/// Build the router and serve it until the process is asked to stop.-pub async fn setup_and_serve<T, R, Opener, Bots, Access, Auth>(- read_state: AgentSessionRouterState<T, Access, Auth>,- control_state: AgentSessionControlState<R, Access, Auth>,- create_state: CreateSessionState<Opener, Bots, Auth>,- gateway_state: RuntimeGatewayState<Auth>,+pub async fn setup_and_serve<T, R, Opener, Bots, Access, Auth, Models>(+ states: ApiStates<T, R, Opener, Bots, Access, Auth, Models>,runtime_commands_ready: tokio::sync::watch::Receiver<bool>,port: u16,shutdown: impl Future<Output = ()> + Send + 'static,@@ -96,8 +123,9 @@ whereBots: BotDirectory,Access: EntityAccessService,Auth: MacroAuthorizationService,+ Models: AgentModelsService,{- let inner = api_router(read_state, control_state, create_state, gateway_state)+ let inner = api_router(states).layer(MacroRequestIdAndTracingLayer::new(Duration::from_millis(200)).into_inner()).merge(health_router(runtime_commands_ready)).layer(macro_cors::cors_layer());@@ -120,11 +148,8 @@ where.context("agent harness service http failed")}-fn api_router<T, R, Opener, Bots, Access, Auth>(- read_state: AgentSessionRouterState<T, Access, Auth>,- control_state: AgentSessionControlState<R, Access, Auth>,- create_state: CreateSessionState<Opener, Bots, Auth>,- gateway_state: RuntimeGatewayState<Auth>,+fn api_router<T, R, Opener, Bots, Access, Auth, Models>(+ states: ApiStates<T, R, Opener, Bots, Access, Auth, Models>,) -> RouterwhereT: AgentSessionService,@@ -133,14 +158,16 @@ whereBots: BotDirectory,Access: EntityAccessService,Auth: MacroAuthorizationService,+ Models: AgentModelsService,{- let agent_sessions = agent_session_read_router(read_state.clone())- .merge(agent_session_control_router(control_state))- .merge(agent_session_create_router(create_state));+ let agent_sessions = agent_session_read_router(states.read.clone())+ .merge(agent_session_control_router(states.control))+ .merge(agent_session_create_router(states.create));Router::new().nest("/agent-sessions", agent_sessions)- .merge(agent_sandbox_size_router(read_state))- .nest("/runtime", runtime_gateway_router(gateway_state))+ .merge(agent_sandbox_size_router(states.read))+ .merge(agent_models_router(states.models))+ .nest("/runtime", runtime_gateway_router(states.gateway))}async fn health(State(ready): State<tokio::sync::watch::Receiver<bool>>) -> StatusCode {diff --git a/services/agent_harness_service/src/api/swagger.rs b/services/agent_harness_service/src/api/swagger.rsindex d57ee78d4c..6ef46c66fe 100644--- a/services/agent_harness_service/src/api/swagger.rs+++ b/services/agent_harness_service/src/api/swagger.rs@@ -1,5 +1,9 @@//! OpenAPI document for the agent harness service's session routes.+use agent_harness::inbound::model_load::{+ self, AgentModelDto, AgentModelsStatusDto, LoadAgentModelsRequest, LoadAgentModelsResponse,+ ModelHarnessDto,+};use agent_runtime_protocol::domain::action::{AgentAction, AgentActionId};use agent_session::domain::model::{SandboxSize, SessionBot};use agent_session::inbound::axum_router::{@@ -9,10 +13,27 @@ use agent_session::inbound::axum_router::{EditQueuedActionRequest, LogDirectionDto, LogFrameDto, QueuedActionDto,RenameAgentSessionRequest, SandboxSizeBody, SessionStatusDto,};-use utoipa::OpenApi;+use utoipa::{+ Modify, OpenApi,+ openapi::security::{Http, HttpAuthScheme, SecurityScheme},+};++struct SecurityAddon;++impl Modify for SecurityAddon {+ fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {+ if let Some(components) = openapi.components.as_mut() {+ components.add_security_scheme(+ "bearerAuth",+ SecurityScheme::Http(Http::new(HttpAuthScheme::Bearer)),+ );+ }+ }+}#[derive(OpenApi)]#[openapi(+ modifiers(&SecurityAddon),info(terms_of_service = "https://macro.com/terms"),paths(axum_router::create_agent_session_handler,@@ -27,6 +48,7 @@ use utoipa::OpenApi;axum_router::put_agent_session_sandbox_size_handler,axum_router::get_agent_sandbox_size_handler,axum_router::put_agent_sandbox_size_handler,+ model_load::load_agent_models_handler,),components(schemas(CreateAgentSessionRequest,@@ -50,7 +72,15 @@ use utoipa::OpenApi;LogDirectionDto,SandboxSize,SandboxSizeBody,+ LoadAgentModelsRequest,+ LoadAgentModelsResponse,+ AgentModelDto,+ AgentModelsStatusDto,+ ModelHarnessDto,)),- tags((name = "agent-sessions", description = "Agent sessions"))+ tags(+ (name = "agent-sessions", description = "Agent sessions"),+ (name = "agent-models", description = "Fresh provider model discovery")+ ))]pub struct ApiDoc;diff --git a/services/agent_harness_service/src/main.rs b/services/agent_harness_service/src/main.rsindex 417996a908..b2ad41f800 100644--- a/services/agent_harness_service/src/main.rs+++ b/services/agent_harness_service/src/main.rs@@ -13,6 +13,7 @@ mod bots_directory;mod config;mod containers;mod harness_bindings;+mod model_providers;mod runtime_commands;mod trigger;@@ -31,11 +32,13 @@ use agent_fold::domain::service::FoldedMessageService;use agent_harness::domain::model::{AgentKind, AgentRuntimeConfig, HarnessCommand, HarnessDefaults, SessionDefaults,};+use agent_harness::domain::model_load::AgentModelsServiceImpl;use agent_harness::domain::ports::AgentRuntimeDirectory as _;use agent_harness::domain::service::AgentHarnessService;use agent_harness::domain::trigger_router::{RoutedTrigger, agent_trigger_bot_id, route_agent_trigger,};+use agent_harness::inbound::model_load::AgentModelsRouterState;use agent_harness::inbound::runtime_gateway::RuntimeGatewayState;use agent_harness::outbound::agent_prompt_composer::LexicalAgentPromptComposer;use agent_harness::outbound::channel_announcer::ChannelAnnouncer;@@ -51,6 +54,7 @@ use agent_harness::outbound::forward::RedisCommandForwarder;use agent_harness::outbound::local::{LocalContainerManager, LocalSettings};use agent_harness::outbound::routing::RoutedContainerManager;use agent_harness::outbound::runtime_registry::{HarnessKeyedConnections, RuntimeRegistry};+use agent_inmem::domain::engine::TurnEngine;use agent_inmem::outbound::acp_mcp::AcpMcpConnector;use agent_inmem::outbound::egress_mcp::EgressMcpClient;use agent_inmem::outbound::log_frames::LogFrameSource;@@ -88,6 +92,7 @@ use github::domain::service::{InstallationTokenConfig, InstallationTokenService}use github::outbound::github_sync_client::GithubSyncClientImpl;use github::outbound::pg_github_sync_repo::PgGithubSyncRepo;use harness_bindings::{PgHarnessBindings, PgHarnessPresence};+use harnesses::outbound::pg_harness_repo::PgHarnessRepo;use kafka_util::{GroupName, KafkaEventConsumer, consumer_span, record_span_error};use lexical_client::LexicalClient;use macro_auth::middleware::decode_jwt::JwtValidationArgs;@@ -104,6 +109,7 @@ use macro_event_broker::{use macro_service_urls::{AgentHarnessEgressUrl, ConnectionGatewayUrl, LexicalServiceUrl, McpServiceUrl,};+use model_providers::{CursorModels, InMemoryModels, MacrodModels, VisibleHarnessAccess};use pipedream_mcp::outbound::api::{PipedreamClient, PipedreamConfig};use pipedream_mcp::outbound::pg_connection_repo::PgConnectionRepo;use rdkafka::consumer::CommitMode;@@ -337,6 +343,7 @@ async fn run() -> anyhow::Result<()> {ReqwestForwarder::new()?,));+ let mut inmem_model_engine: Option<Arc<dyn TurnEngine>> = None;let inmem = match inmem_bot {Some(_) => {let tool_context = ai_tools::build_tool_service_context_from_env(@@ -346,6 +353,7 @@ async fn run() -> anyhow::Result<()> {.await.context("failed to build the in-memory agent tool context")?;let engine = Arc::new(RigTurnEngine::new(pool.clone(), tool_context));+ inmem_model_engine = Some(engine.clone());// Cold attaches (fresh spawns and post-restart resumes) rebuild// their model context from the same log every frame lands in.let frames = Arc::new(LogFrameSource::new(session_repo.clone()));@@ -378,13 +386,14 @@ async fn run() -> anyhow::Result<()> {// owner's key at spawn. Decrypt-only — registering keys belongs to the// authentication service, and a harness that could encrypt would be a// harness whose IAM role grants more than it uses.+ let cursor_keys = PgCursorApiKeys::new(+ pool.clone(),+ KmsCursorApiKeyCipher::new(AwsKmsCiphertexts::decrypting(aws_sdk_kms::Client::new(+ &aws_config,+ ))),+ );let cursor_manager = CursorContainerManager::new(- PgCursorApiKeys::new(- pool.clone(),- KmsCursorApiKeyCipher::new(AwsKmsCiphertexts::decrypting(aws_sdk_kms::Client::new(- &aws_config,- ))),- ),+ cursor_keys.clone(),CURSOR_API_BASE_URL.to_owned(),CursorRepoUrl::parse(&config.cursor_repo_url).context("CURSOR_REPO_URL is not a valid repository url")?,@@ -533,6 +542,10 @@ async fn run() -> anyhow::Result<()> {// Close the loop: turn ends observed by the session actors drain the// harness's prompt queue.turn_observer.bind(harness.clone());+ let model_probe_timeout = std::time::Duration::from_secs(10);+ let macrod_models =+ MacrodModels::new(Arc::clone(&runtimes), redis.clone(), model_probe_timeout);+ let runtime_command_models = macrod_models.clone();let runtime_command_redis = redis.clone();let runtime_command_harness = harness.clone();let runtime_command_runtimes = Arc::clone(&runtimes);@@ -553,6 +566,7 @@ async fn run() -> anyhow::Result<()> {},runtime_command_harness.clone(),runtime_commands_ready.clone(),+ runtime_command_models.clone(),)},)@@ -589,6 +603,17 @@ async fn run() -> anyhow::Result<()> {.with_harness_authorizer(PgHarnessAuthorizer::new(PgHarnessAuthorizationRepo::new(pool.clone(),)));+ let model_service = Arc::new(AgentModelsServiceImpl::new(+ VisibleHarnessAccess::new(PgHarnessRepo::new(pool.clone())),+ InMemoryModels::new(inmem_model_engine, config.inmem_model.clone()),+ CursorModels::new(cursor_keys, CURSOR_API_BASE_URL.to_owned()),+ macrod_models,+ model_probe_timeout,+ ));+ let model_state = AgentModelsRouterState::new(+ model_service,+ MacroAuthorizationState::new(Arc::new(authorization_service.clone())),+ );let read_state = AgentSessionRouterState::new(AgentSessionServiceImpl::new(session_repo.clone(),@@ -617,10 +642,13 @@ async fn run() -> anyhow::Result<()> {let http_port = config.port;let http = tokio::spawn(async move {if let Err(error) = api::setup_and_serve(- read_state,- control_state,- create_state,- gateway_state,+ api::ApiStates::new(+ read_state,+ control_state,+ create_state,+ gateway_state,+ model_state,+ ),http_runtime_commands_readiness,http_port,shutdown_signal(),diff --git a/services/agent_harness_service/src/model_providers/access.rs b/services/agent_harness_service/src/model_providers/access.rsnew file mode 100644index 0000000000..1ec3224e95--- /dev/null+++ b/services/agent_harness_service/src/model_providers/access.rs@@ -0,0 +1,38 @@+//! Authorization adapter for registered harness model discovery.++use agent_harness::domain::model_load::HarnessModelAccess;+use harness_id::HarnessId;+use harnesses::domain::ports::{HarnessRepo, HarnessService};+use harnesses::domain::service::HarnessServiceImpl;+use macro_user_id::user_id::MacroUserIdStr;++/// Visibility adapter backed by the harness domain's existing list policy.+pub struct VisibleHarnessAccess<Repo> {+ harnesses: HarnessServiceImpl<Repo>,+}++impl<Repo> VisibleHarnessAccess<Repo> {+ /// Build an access adapter over the harness repository.+ pub fn new(repo: Repo) -> Self {+ Self {+ harnesses: HarnessServiceImpl::new(repo),+ }+ }+}++impl<Repo> HarnessModelAccess for VisibleHarnessAccess<Repo>+where+ Repo: HarnessRepo,+{+ async fn can_use(+ &self,+ caller: &MacroUserIdStr<'static>,+ harness: HarnessId,+ ) -> Result<bool, String> {+ self.harnesses+ .list_harnesses(caller.clone())+ .await+ .map(|visible| visible.iter().any(|candidate| candidate.id == harness))+ .map_err(|error| error.to_string())+ }+}diff --git a/services/agent_harness_service/src/model_providers/cursor.rs b/services/agent_harness_service/src/model_providers/cursor.rsnew file mode 100644index 0000000000..12fb5de152--- /dev/null+++ b/services/agent_harness_service/src/model_providers/cursor.rs@@ -0,0 +1,58 @@+//! Cursor model discovery adapter.++use agent_harness::domain::model_load::{CursorModelProbe, ModelProbeError, RawModelProbe};+use agent_harness::outbound::cursor::CursorApiKeys;+use cursor_cloud_agents::api::{ApiKey, CursorClient, CursorConfig};+use cursor_cloud_agents::domain::model_options::cursor_model_config_options;+use cursor_cloud_agents::domain::ports::CursorAgents;+use macro_user_id::user_id::MacroUserIdStr;++#[cfg(test)]+mod test;++/// Cursor catalog adapter resolving one caller's key for every request.+pub struct CursorModels<Keys> {+ keys: Keys,+ base_url: String,+}++impl<Keys> CursorModels<Keys> {+ /// Build an adapter over the per-user key source and Cursor API.+ pub fn new(keys: Keys, base_url: String) -> Self {+ Self { keys, base_url }+ }+}++impl<Keys> CursorModelProbe for CursorModels<Keys>+where+ Keys: CursorApiKeys,+{+ async fn probe(+ &self,+ caller: &MacroUserIdStr<'static>,+ ) -> Result<RawModelProbe, ModelProbeError> {+ let config = self+ .keys+ .resolve(caller)+ .await+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ let client = CursorClient::new(CursorConfig {+ api_key: ApiKey::new(config.key.expose()),+ base_url: self.base_url.clone(),+ model: None,+ starting_ref: "main".to_owned(),+ record_dir: None,+ })+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ let models = client+ .list_models()+ .await+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ let current = config+ .default_model_id+ .filter(|current| models.iter().any(|model| model.id == *current));+ Ok(RawModelProbe::Options(cursor_model_config_options(+ &models, current,+ )))+ }+}diff --git a/services/agent_harness_service/src/model_providers/cursor/test.rs b/services/agent_harness_service/src/model_providers/cursor/test.rsnew file mode 100644index 0000000000..ef1a567623--- /dev/null+++ b/services/agent_harness_service/src/model_providers/cursor/test.rs@@ -0,0 +1,70 @@+use std::sync::{Arc, Mutex};++use agent_harness::domain::model_load::{CursorModelProbe as _, RawModelProbe};+use agent_harness::outbound::cursor::keys::ResolvedCursorConfig;+use axum::extract::{Request, State};+use axum::routing::any;+use axum::{Json, Router};+use cursor_api_key::cipher::CursorApiKey;++use super::*;++struct TestCursorKeys;++impl CursorApiKeys for TestCursorKeys {+ async fn resolve(+ &self,+ _owner: &MacroUserIdStr<'_>,+ ) -> agent_harness::domain::error::Result<ResolvedCursorConfig> {+ Ok(ResolvedCursorConfig {+ key: CursorApiKey::parse("crsr_test").unwrap(),+ default_model_id: Some("fast".to_owned()),+ })+ }+}++/// Every (method, path) the fake Cursor API was asked for.+type RecordedCalls = Arc<Mutex<Vec<(String, String)>>>;++async fn cursor_api(+ State(calls): State<RecordedCalls>,+ request: Request,+) -> Json<serde_json::Value> {+ calls.lock().unwrap().push((+ request.method().to_string(),+ request.uri().path().to_owned(),+ ));+ Json(serde_json::json!({+ "items": [+ {"id": "default", "displayName": "Auto", "variants": []},+ {"id": "fast", "displayName": "Fast", "variants": []}+ ]+ }))+}++#[tokio::test]+async fn probe_lists_models_without_creating_an_agent() {+ let calls = Arc::new(Mutex::new(Vec::new()));+ let app = Router::new()+ .fallback(any(cursor_api))+ .with_state(Arc::clone(&calls));+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });+ let provider = CursorModels::new(TestCursorKeys, format!("http://{address}"));++ let RawModelProbe::Options(options) = provider+ .probe(&MacroUserIdStr::try_from_email("[email protected]").unwrap())+ .await+ .unwrap()+ else {+ panic!("cursor should return options");+ };++ assert_eq!(options.len(), 1);+ assert_eq!(+ calls.lock().unwrap().as_slice(),+ &[("GET".to_owned(), "/v1/models".to_owned())]+ );+ server.abort();+}diff --git a/services/agent_harness_service/src/model_providers/in_memory.rs b/services/agent_harness_service/src/model_providers/in_memory.rsnew file mode 100644index 0000000000..6c306f9e99--- /dev/null+++ b/services/agent_harness_service/src/model_providers/in_memory.rs@@ -0,0 +1,33 @@+//! In-memory model discovery adapter.++use std::sync::Arc;++use agent_harness::domain::model_load::{InMemoryModelProbe, ModelProbeError, RawModelProbe};+use agent_inmem::domain::engine::TurnEngine;++/// In-memory catalog adapter over the same engine used for turns.+pub struct InMemoryModels {+ engine: Option<Arc<dyn TurnEngine>>,+ current: String,+}++impl InMemoryModels {+ /// Build an adapter over the optional in-memory engine.+ pub fn new(engine: Option<Arc<dyn TurnEngine>>, current: String) -> Self {+ Self { engine, current }+ }+}++impl InMemoryModelProbe for InMemoryModels {+ async fn probe(&self) -> Result<RawModelProbe, ModelProbeError> {+ let Some(engine) = &self.engine else {+ return Ok(RawModelProbe::Unsupported);+ };+ Ok(RawModelProbe::Options(+ agent_inmem::domain::model_options::model_config_options(+ &self.current,+ engine.supported_models(),+ ),+ ))+ }+}diff --git a/services/agent_harness_service/src/model_providers/macrod.rs b/services/agent_harness_service/src/model_providers/macrod.rsnew file mode 100644index 0000000000..60dca1d1a5--- /dev/null+++ b/services/agent_harness_service/src/model_providers/macrod.rs@@ -0,0 +1,124 @@+//! Model discovery over the existing Redis runtime bus.++use std::sync::Arc;+use std::time::Duration;++use agent_harness::domain::model_load::{MacrodModelProbe, ModelProbeError, RawModelProbe};+use agent_harness::inbound::runtime_gateway::GatewaySender;+use agent_harness::outbound::forward::COMMAND_CHANNEL;+use agent_harness::outbound::runtime_registry::RuntimeRegistry;+use agent_runtime_protocol::domain::schema::v0::ModelProbeResult;+use harness_id::HarnessId;+use redis::AsyncCommands as _;+use tokio::sync::broadcast;++#[cfg(test)]+mod test;++/// Probe events broadcast alongside existing runtime commands.+#[derive(Clone, serde::Serialize, serde::Deserialize)]+#[serde(tag = "type", rename_all = "camelCase")]+pub(crate) enum ModelProbeEvent {+ /// Whichever replica holds this socket should perform a local probe.+ ProbeModels { harness: HarnessId },+ /// A fresh observation available to every replica waiting on this harness.+ ModelsProbed {+ harness: HarnessId,+ result: ModelProbeResult,+ },+}++/// Macrod adapter using the shared runtime bus on every replica.+#[derive(Clone)]+pub struct MacrodModels {+ runtimes: Arc<RuntimeRegistry<GatewaySender>>,+ redis: redis::Client,+ observations: broadcast::Sender<(HarnessId, ModelProbeResult)>,+ timeout: Duration,+}++impl MacrodModels {+ /// Build the bus publisher and local observer shared with its consumer.+ pub fn new(+ runtimes: Arc<RuntimeRegistry<GatewaySender>>,+ redis: redis::Client,+ timeout: Duration,+ ) -> Self {+ Self {+ runtimes,+ redis,+ observations: broadcast::channel(128).0,+ timeout,+ }+ }++ /// Handle a bus event independently of HTTP requests and other commands.+ pub(crate) async fn observe(&self, event: ModelProbeEvent) -> Result<(), ModelProbeError> {+ match event {+ ModelProbeEvent::ModelsProbed { harness, result } => {+ // Nobody waiting is normal: all replicas receive the event.+ let _ = self.observations.send((harness, result));+ Ok(())+ }+ ModelProbeEvent::ProbeModels { harness } => {+ let result =+ match tokio::time::timeout(self.timeout, self.runtimes.probe_models(harness))+ .await+ {+ // Only the socket-owning replica answers.+ Ok(None) => return Ok(()),+ Ok(Some(Ok(config_options))) => {+ ModelProbeResult::Available { config_options }+ }+ Ok(Some(Err(error))) => ModelProbeResult::Error {+ message: error.to_string(),+ },+ Err(_) => ModelProbeResult::Error {+ message: "the ACP model probe timed out".to_owned(),+ },+ };+ self.publish(ModelProbeEvent::ModelsProbed { harness, result })+ .await+ }+ }+ }++ async fn publish(&self, event: ModelProbeEvent) -> Result<(), ModelProbeError> {+ let payload = serde_json::to_string(&event)+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ let mut connection = self+ .redis+ .get_multiplexed_async_connection()+ .await+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ connection+ .publish::<_, _, ()>(COMMAND_CHANNEL, payload)+ .await+ .map_err(|error| ModelProbeError::Failed(error.to_string()))+ }+}++impl MacrodModelProbe for MacrodModels {+ async fn probe(&self, harness: HarnessId) -> Result<RawModelProbe, ModelProbeError> {+ // Observe first, so even an immediate answer cannot be missed.+ // Concurrent callers for this harness may use the same fresh observation.+ let mut observations = self.observations.subscribe();+ self.publish(ModelProbeEvent::ProbeModels { harness })+ .await?;+ loop {+ let (observed_harness, result) = observations+ .recv()+ .await+ .map_err(|error| ModelProbeError::Failed(error.to_string()))?;+ if observed_harness != harness {+ continue;+ }+ return match result {+ ModelProbeResult::Available { config_options } => {+ Ok(RawModelProbe::Options(config_options))+ }+ ModelProbeResult::Error { message } => Err(ModelProbeError::Failed(message)),+ };+ }+ }+}diff --git a/services/agent_harness_service/src/model_providers/macrod/test.rs b/services/agent_harness_service/src/model_providers/macrod/test.rsnew file mode 100644index 0000000000..d0a253ed27--- /dev/null+++ b/services/agent_harness_service/src/model_providers/macrod/test.rs@@ -0,0 +1,210 @@+use super::*;+use agent_client_protocol::schema::v1::{SessionConfigOption, SessionConfigSelectOption};+use agent_harness::domain::error::Result as HarnessResult;+use agent_harness::domain::model::{CommandOutcome, HarnessCommand};+use agent_harness::domain::service::ForwardedCommands;+use agent_runtime_protocol::domain::channel::Channel;+use agent_runtime_protocol::domain::schema::v0::{ToRuntimeMessage, ToServerMessage};+use agent_session::domain::model::{AgentSessionId, ReplicaId};++struct NoCommands;++impl ForwardedCommands for NoCommands {+ async fn execute_forwarded(+ &self,+ _: AgentSessionId,+ _: HarnessCommand,+ ) -> HarnessResult<CommandOutcome> {+ panic!("model discovery must not create or execute session commands")+ }+}++struct Peer {+ models: MacrodModels,+ registry: Arc<RuntimeRegistry<GatewaySender>>,+ consumer: tokio::task::JoinHandle<anyhow::Result<()>>,+}++impl Drop for Peer {+ fn drop(&mut self) {+ self.consumer.abort();+ }+}++async fn peer() -> Peer {+ let url = macro_env_var::optional_read_env_var("REDIS_URI")+ .ok()+ .flatten()+ .unwrap_or_else(|| "redis://127.0.0.1:6379".to_owned());+ let redis = redis::Client::open(url).unwrap();+ let registry = RuntimeRegistry::new();+ let models = MacrodModels::new(Arc::clone(®istry), redis.clone(), Duration::from_secs(2));+ let (ready, mut readiness) = tokio::sync::watch::channel(false);+ let consumer = tokio::spawn(crate::runtime_commands::consume_runtime_commands(+ redis,+ ReplicaId::mint(),+ {+ let registry = Arc::clone(®istry);+ Arc::new(move |harness| registry.is_connected(harness))+ },+ Arc::new(NoCommands),+ ready,+ models.clone(),+ ));+ tokio::time::timeout(Duration::from_secs(2), readiness.wait_for(|ready| *ready))+ .await+ .unwrap()+ .unwrap();+ Peer {+ models,+ registry,+ consumer,+ }+}++fn harness_id() -> HarnessId {+ HarnessId::new_from_uuid(macro_uuid::generate_uuid_v7())+}++fn options() -> Vec<SessionConfigOption> {+ vec![SessionConfigOption::select(+ "model",+ "Model",+ "fast",+ vec![SessionConfigSelectOption::new("fast", "Fast")],+ )]+}++async fn probe_through_bus(remote: bool) {+ let origin = peer().await;+ let other = peer().await;+ let owner = if remote { &other } else { &origin };+ let harness = harness_id();+ let (carrier, mut runtime) = Channel::duplex();+ owner.registry.attach(harness, carrier);++ let (result, ()) = tokio::time::timeout(Duration::from_secs(3), async {+ tokio::join!(origin.models.probe(harness), async {+ assert!(matches!(+ runtime.rx.recv().await.unwrap(),+ ToRuntimeMessage::ModelProbeRequest+ ));+ runtime+ .tx+ .send(ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Available {+ config_options: options(),+ },+ })+ .unwrap();+ })+ })+ .await+ .expect("probe crosses Redis and returns");++ let RawModelProbe::Options(actual) = result.unwrap() else {+ panic!("the runtime advertised options");+ };+ assert_eq!(actual, options());+ assert!(runtime.rx.try_recv().is_err(), "only one replica probes");+}++#[tokio::test]+async fn remote_socket_owner_probes_and_broadcasts_models_to_origin() {+ probe_through_bus(true).await;+}++#[tokio::test]+async fn local_socket_owner_uses_the_same_bus_path() {+ probe_through_bus(false).await;+}++#[tokio::test]+async fn remote_probe_errors_reach_the_waiting_replica() {+ let origin = peer().await;+ let owner = peer().await;+ let harness = harness_id();+ let (carrier, mut runtime) = Channel::duplex();+ owner.registry.attach(harness, carrier);+ let (result, ()) = tokio::time::timeout(Duration::from_secs(3), async {+ tokio::join!(origin.models.probe(harness), async {+ runtime.rx.recv().await.unwrap();+ runtime+ .tx+ .send(ToServerMessage::ModelProbeResponse {+ result: ModelProbeResult::Error {+ message: "probe failed".to_owned(),+ },+ })+ .unwrap();+ })+ })+ .await+ .unwrap();+ assert!(matches!(result, Err(ModelProbeError::Failed(_))));+}++#[tokio::test]+async fn absent_owner_waits_for_caller_timeout_and_ignores_other_harness_results() {+ let origin = peer().await;+ let harness = harness_id();+ let result = tokio::time::timeout(Duration::from_millis(100), async {+ tokio::join!(origin.models.probe(harness), async {+ origin+ .models+ .publish(ModelProbeEvent::ModelsProbed {+ harness: harness_id(),+ result: ModelProbeResult::Available {+ config_options: options(),+ },+ })+ .await+ .unwrap();+ })+ })+ .await;+ assert!(+ result.is_err(),+ "an unrelated harness cannot satisfy the probe"+ );+ assert_eq!(+ origin.models.observations.receiver_count(),+ 0,+ "cancellation removes the waiter"+ );+}++#[tokio::test]+async fn concurrent_callers_can_observe_the_same_fresh_harness_result() {+ let first = peer().await;+ let second = peer().await;+ let owner = peer().await;+ let harness = harness_id();+ // Use a controlled observation to exercise fanout independently of the+ // runtime's probe serialization.+ let one = first.models.probe(harness);+ let two = second.models.probe(harness);+ let (one, two, ()) = tokio::time::timeout(Duration::from_secs(3), async {+ tokio::join!(one, two, async {+ while first.models.observations.receiver_count() == 0+ || second.models.observations.receiver_count() == 0+ {+ tokio::task::yield_now().await;+ }+ owner+ .models+ .publish(ModelProbeEvent::ModelsProbed {+ harness,+ result: ModelProbeResult::Available {+ config_options: options(),+ },+ })+ .await+ .unwrap();+ })+ })+ .await+ .unwrap();+ assert!(matches!(one, Ok(RawModelProbe::Options(_))));+ assert!(matches!(two, Ok(RawModelProbe::Options(_))));+}diff --git a/services/agent_harness_service/src/model_providers/mod.rs b/services/agent_harness_service/src/model_providers/mod.rsnew file mode 100644index 0000000000..2392983cba--- /dev/null+++ b/services/agent_harness_service/src/model_providers/mod.rs@@ -0,0 +1,12 @@+//! Concrete outbound adapters for fresh model discovery.++mod access;+mod cursor;+mod in_memory;+mod macrod;++pub use access::VisibleHarnessAccess;+pub use cursor::CursorModels;+pub use in_memory::InMemoryModels;+pub use macrod::MacrodModels;+pub(crate) use macrod::ModelProbeEvent;diff --git a/services/agent_harness_service/src/runtime_commands.rs b/services/agent_harness_service/src/runtime_commands.rsindex 2e710ff6e7..620eea89df 100644--- a/services/agent_harness_service/src/runtime_commands.rs+++ b/services/agent_harness_service/src/runtime_commands.rs@@ -2,6 +2,8 @@use std::sync::Arc;+use crate::model_providers::{MacrodModels, ModelProbeEvent};+use agent_harness::domain::service::ForwardedCommands;use agent_harness::outbound::forward::{COMMAND_CHANNEL, RuntimeCommandRequest, RuntimeCommandTarget,@@ -16,12 +18,20 @@ use tracing::Instrument as _;#[cfg(test)]mod test;+#[derive(serde::Deserialize)]+#[serde(untagged)]+enum RuntimeBusEvent {+ Models(ModelProbeEvent),+ Command(Box<RuntimeCommandRequest>),+}+pub(crate) async fn consume_runtime_commands<Harness>(redis: redis::Client,replica: ReplicaId,connected: Arc<dyn Fn(HarnessId) -> bool + Send + Sync>,harness_service: Arc<Harness>,ready: tokio::sync::watch::Sender<bool>,+ models: MacrodModels,) -> anyhow::Result<()>whereHarness: ForwardedCommands,@@ -30,7 +40,20 @@ wheresubscriber.subscribe(COMMAND_CHANNEL).await?;ready.send_replace(true);let mut requests = subscriber.into_on_message();- while let Some(request) = requests.next().await {+ let mut probes = tokio::task::JoinSet::new();+ loop {+ let request = tokio::select! {+ request = requests.next() => match request {+ Some(request) => request,+ None => break,+ },+ result = probes.join_next(), if !probes.is_empty() => {+ if let Some(Err(error)) = result {+ tracing::error!(error = ?error, "runtime model observer task failed");+ }+ continue;+ }+ };let payload: String = match request.get_payload() {Ok(payload) => payload,Err(error) => {@@ -38,13 +61,29 @@ wherecontinue;}};- let request: RuntimeCommandRequest = match serde_json::from_str(&payload) {+ let event: RuntimeBusEvent = match serde_json::from_str(&payload) {Ok(request) => request,Err(error) => {tracing::warn!(error = ?error, "dropping malformed runtime command broadcast");continue;}};+ let request = match event {+ RuntimeBusEvent::Command(request) => *request,+ RuntimeBusEvent::Models(event) => {+ let models = models.clone();+ probes.spawn(async move {+ models+ .observe(event)+ .await+ .inspect_err(|error| {+ tracing::error!(error = ?error, "runtime model bus event failed");+ })+ .ok();+ });+ continue;+ }+ };let redis = redis.clone();let harness_service = Arc::clone(&harness_service);let connected = Arc::clone(&connected);diff --git a/services/agent_harness_service/src/runtime_commands/test.rs b/services/agent_harness_service/src/runtime_commands/test.rsindex 56eefb5158..38f70357f6 100644--- a/services/agent_harness_service/src/runtime_commands/test.rs+++ b/services/agent_harness_service/src/runtime_commands/test.rs@@ -78,6 +78,7 @@ async fn a_command_executes_on_exactly_one_responsible_replica() {Arc::new(|_| false),Arc::clone(&origin_harness),origin_ready,+ empty_models(redis.clone()),));let (peer_ready, mut peer_readiness) = tokio::sync::watch::channel(false);let peer_consumer = tokio::spawn(consume_runtime_commands(@@ -86,6 +87,7 @@ async fn a_command_executes_on_exactly_one_responsible_replica() {Arc::new(|_| false),Arc::clone(&peer_harness),peer_ready,+ empty_models(redis.clone()),));ready(&mut origin_readiness).await;ready(&mut peer_readiness).await;@@ -118,6 +120,7 @@ async fn a_responsible_replicas_error_does_not_fail_the_publish() {Arc::new(|_| false),Arc::clone(&harness),ready_tx,+ empty_models(redis.clone()),));ready(&mut readiness).await;@@ -146,6 +149,7 @@ async fn publishing_without_an_owner_still_succeeds() {Arc::new(|_| false),Arc::clone(&harness),ready_tx,+ empty_models(redis.clone()),));ready(&mut readiness).await;@@ -177,6 +181,7 @@ async fn overlapping_harness_connections_execute_once() {Arc::new(move |harness| harness == target),Arc::clone(&first),first_ready,+ empty_models(redis.clone()),));let (second_ready, mut second_readiness) = tokio::sync::watch::channel(false);let second_consumer = tokio::spawn(consume_runtime_commands(@@ -185,6 +190,7 @@ async fn overlapping_harness_connections_execute_once() {Arc::new(move |harness| harness == target),Arc::clone(&second),second_ready,+ empty_models(redis.clone()),));ready(&mut first_readiness).await;ready(&mut second_readiness).await;@@ -212,3 +218,11 @@ async fn overlapping_harness_connections_execute_once() {first_consumer.abort();second_consumer.abort();}++fn empty_models(redis: redis::Client) -> MacrodModels {+ MacrodModels::new(+ agent_harness::outbound::runtime_registry::RuntimeRegistry::new(),+ redis,+ std::time::Duration::from_secs(2),+ )+}diff --git a/services/coding-agent-worker/src/protocol/generated.ts b/services/coding-agent-worker/src/protocol/generated.tsindex e825322c3f..739a157b0e 100644--- a/services/coding-agent-worker/src/protocol/generated.ts+++ b/services/coding-agent-worker/src/protocol/generated.ts@@ -18,12 +18,31 @@*/export type AcpMessage = { [key in string]: unknown };+/** The result of probing a fresh ACP subprocess. */+export type ModelProbeResult =+/** The raw options returned by `session/new`. */+{ status: "available";+/** Session configuration options exactly as the agent returned them. */+configOptions: unknown[] } |+/** A safe, operator-actionable failure description. */+{ status: "error";+/** Failure text safe to return across the runtime connection. */+message: string };+/** Agent Service to Agent Runtime traffic on the logical protocol stream. */export type ToRuntimeMessage =/** An ACP message routed to the hosted agent. */{type: "acp",-} & AcpMessage;+} & AcpMessage |+/**+ * Probe a separate fresh agent process for its session configuration.+ *+ * The request carries no parameters: it asks this connection's one+ * configured harness what it advertises. Answers are therefore+ * interchangeable, so nothing correlates a response to a request.+ */+{ type: "modelProbeRequest" };/** Agent Runtime to Agent Service traffic on the logical protocol stream. */export type ToServerMessage =@@ -32,6 +51,10 @@ export type ToServerMessage =type: "acp",} & AcpMessage |/** A runtime or agent lifecycle event. */-{ type: "event";+({ type: "event";/** The event name. */-event: string };+event: string }) & { result?: never } |+/** An answer to a connection-level model probe. */+({ type: "modelProbeResponse";+/** Raw options or a safe failure. */+result: ModelProbeResult }) & { event?: never };