Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

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.json
index 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.lock
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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={
<select
id="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. Recommended
diff --git a/apps/web/src/features/settings/HarnessPairingDialog.test.tsx b/apps/web/src/features/settings/HarnessPairingDialog.test.tsx
index 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.tsx
index 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: {
visibleScrim
class="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()}>
<Button
type="button"
variant="ghost"
diff --git a/apps/web/src/lib/queries/agents/models.test.tsx b/apps/web/src/lib/queries/agents/models.test.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
index 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.ts
index 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/listOccurrencesP
import 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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 @@ where
pub 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.toml
index 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.rs
index 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<(), AcpErr
let 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.rs
index 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)
where
Engine: 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 @@ where
handshake,
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 @@ where
self.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 @@ where
match 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 @@ where
self.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> {
bound
diff --git a/crates/agent_session/src/domain/connection/test.rs b/crates/agent_session/src/domain/connection/test.rs
index 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.rs
index 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.rs
index 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<(), Br
outcome.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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.toml
index 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.rs
index 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())
.await
diff --git a/docs/AGENT_GUIDE/surfaces.md b/docs/AGENT_GUIDE/surfaces.md
index 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 grouped
Profile, 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.
+
## Notifications
Toast regions are labeled `Notifications (alt+T)`; five empty live regions always exist in
diff --git a/packages/sdk/generated/agent-harness/index.ts b/packages/sdk/generated/agent-harness/index.ts
index 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-ts
export { 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.ts
index 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.ts
index 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.json
index 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.ts
index 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.gen
import 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.toml
index 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.rs
index 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 @@ where
Bots: 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>,
) -> Router
where
T: AgentSessionService,
@@ -133,14 +158,16 @@ where
Bots: 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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(&registry), 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(&registry);
+ 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.rs
new file mode 100644
index 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.rs
index 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<()>
where
Harness: ForwardedCommands,
@@ -30,7 +40,20 @@ where
subscriber.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 @@ where
continue;
}
};
- 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.rs
index 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.ts
index 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 };