@devries-cameron20 / t3code-1 / commits / 4c9189275a
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): delegate_task accepts the inherited options orchestrator_capabilities reports (#28133)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Etan Heyman committed Nov 1, 2026 at 04:46 UTC 4c9189275aef34290df831b5596aa3c9fff1498c
2 files changed +112 -4
apps/server/src/mcp/OrchestratorMcpService.test.ts
+90
@@ -2979,6 +2979,96 @@ describe("OrchestratorMcpService provider resolution", () => {
2979 }),
2980 );
2981
2982 + it.effect("accepts the inherited options it reports back as a delegate target", () =>
2983 + Effect.gen(function* () {
2984 + // t3_thread_launch keeps a model selection as given, so a thread can hold an option its model lacks.
2985 + const inherited = {
2986 + instanceId: codexInstanceId,
2987 + model: "gpt-5.4",
2988 + options: [
2989 + { id: "reasoningEffort", value: "low" },
2990 + { id: "fastMode", value: false },
2991 + ],
2992 + } as const;
2993 + const commands: Array<{ readonly modelSelection?: unknown }> = [];
2994 + const task = {
2995 + id: taskId,
2996 + threadId: parentThreadId,
2997 + origin: "app_owned",
2998 + childThreadId,
2999 + providerInstanceId: codexInstanceId,
3000 + model: inherited.model,
3001 + status: "running",
3002 + result: null,
3003 + };
3004 + const dependencies = Layer.mergeAll(
3005 + NodeServices.layer,
3006 + Layer.mock(ThreadManagementService.ThreadManagementService)({
3007 + hasReceipt: () => Effect.succeed(false),
3008 + assertProviderInstanceEnabled: () => Effect.void,
3009 + getThreadRecords: (threadId) =>
3010 + Effect.succeed(
3011 + threadId === parentThreadId
3012 + ? parentProjection(commands.length > 0 ? [task] : [], inherited)
3013 + : childProjection,
3014 + ),
3015 + dispatch: (command) =>
3016 + Effect.sync(() => {
3017 + commands.push(command as { readonly modelSelection?: unknown });
3018 + return {
3019 + sequence: 1,
3020 + storedEvents: [{ event: { type: "subagent.updated", payload: task } }],
3021 + } as never;
3022 + }),
3023 + }),
3024 + ServerSettings.layerTest(),
3025 + providerRegistryLayer([
3026 + {
3027 + ...providerSnapshot({
3028 + instanceId: codexInstanceId,
3029 + driver: ProviderDriverKind.make("codex"),
3030 + }),
3031 + models: [
3032 + {
3033 + slug: inherited.model,
3034 + name: inherited.model,
3035 + isCustom: false,
3036 + capabilities: {
3037 + optionDescriptors: [
3038 + {
3039 + id: "reasoningEffort",
3040 + label: "Reasoning",
3041 + type: "select",
3042 + options: [{ id: "low", label: "Low" }],
3043 + },
3044 + ],
3045 + },
3046 + },
3047 + ],
3048 + },
3049 + ]),
3050 + adapterRegistryLayer([codexInstanceId]),
3051 + Layer.mock(ProjectService.ProjectService)({}),
3052 + Layer.mock(SecretRequests.SecretRequests)({}),
3053 + Layer.mock(RemoteDelegation.RemoteDelegation)({}),
3054 + Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
3055 + );
3056 + yield* Effect.gen(function* () {
3057 + const service = yield* OrchestratorMcpService.OrchestratorMcpService;
3058 + const { inheritedOptions } = yield* service.capabilities(scope);
3059 + yield* service.delegateTask(scope, {
3060 + task: "Review the change.",
3061 + target: yield* decodeTarget({ options: inheritedOptions }),
3062 + mode: "async",
3063 + });
3064 + assert.deepEqual(commands[0]?.modelSelection, {
3065 + ...inherited,
3066 + options: [inherited.options[0]],
3067 + });
3068 + }).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(dependencies))));
3069 + }),
3070 + );
3071 +
3072 describe("resolveRuntimeMode", () => {
3073 const muse = {
3074 modelSelection: { instanceId: ProviderInstanceId.make("muse"), model: "muse-model" },
apps/server/src/mcp/OrchestratorMcpService.ts
+22 -4
@@ -365,6 +365,15 @@ function providerConstraints(
365 return constraints;
366 }
367
368 +/** t3_thread_launch keeps a selection as given, so it can hold options its model does not have. */
369 +function knownOptions(
370 + options: ReadonlyArray<ProviderOptionSelection> | undefined,
371 + descriptors: ReadonlyArray<ProviderOptionDescriptor> | undefined,
372 +): ReadonlyArray<ProviderOptionSelection> | undefined {
373 + if (options === undefined || descriptors === undefined) return options;
374 + return options.filter((option) => descriptors.some((descriptor) => descriptor.id === option.id));
375 +}
376 +
377 /** Skip checks without descriptors; reject duplicate IDs because consumers disagree on precedence. */
378 function invalidOptionSelections(
379 selections: ReadonlyArray<ProviderOptionSelection>,
@@ -1394,10 +1403,10 @@ const make = Effect.gen(function* () {
1403 );
1404 }
1405
1406 + const descriptors = provider.models.find((candidate) => candidate.slug === model)?.capabilities
1407 + ?.optionDescriptors;
1408 const requestedOptions = input.target?.options;
1409 if (requestedOptions !== undefined) {
1399 - const descriptors = provider.models.find((candidate) => candidate.slug === model)
1400 - ?.capabilities?.optionDescriptors;
1410 const invalid = invalidOptionSelections(requestedOptions, descriptors);
1411 if (invalid.length > 0) {
1412 return yield* failure(
@@ -1409,7 +1418,9 @@ const make = Effect.gen(function* () {
1418
1419 const inheritsOptions =
1420 instanceId === inheritedSelection.instanceId && model === inheritedSelection.model;
1412 - let options = inheritsOptions ? inheritedSelection.options : undefined;
1421 + let options = inheritsOptions
1422 + ? knownOptions(inheritedSelection.options, descriptors)
1423 + : undefined;
1424 if (requestedOptions !== undefined) {
1425 const selections = new Map(
1426 (requestedOptions.length === 0 ? [] : (options ?? [])).map((selection) => [
@@ -2227,7 +2238,14 @@ const make = Effect.gen(function* () {
2238 parentThreadId: parent?.thread.id ?? null,
2239 inheritedProviderInstanceId: inherited?.instanceId ?? null,
2240 inheritedModel: inherited?.model ?? null,
2230 - inheritedOptions: inherited?.options ?? [],
2241 + inheritedOptions:
2242 + knownOptions(
2243 + inherited?.options,
2244 + providers
2245 + .find((provider) => provider.instanceId === inherited?.instanceId)
2246 + ?.models.find((model) => model.slug === inherited?.model)?.capabilities
2247 + ?.optionDescriptors,
2248 + ) ?? [],
2249 runtimeMode: limits.runtimeMode,
2250 interactionMode: limits.interactionMode,
2251 providers: providers.map((provider) => {