From c79771f7cc3f81e6a17697ecebc5d4b8901d1e3e Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 05:11:17 +0000 Subject: [PATCH 1/2] fix(server): reject a model the provider instance does not serve A launch with claudeAgent and grok/grok-4.7 was accepted and ran on the Claude harness. Paths that start work now check that instance's catalog and name the models it serves. Model: grok-4.7 Task: CLO-946 refuse a model the provider instance does not serve Agent: magpie Lane: magpie Harness: t3/codex Model-family: Grok Model-generation: 4.7 Skills-SHA: 0540352af0d6f43bdeea39a8c4aad4660ab0ec55 Co-Authored-By: Grok 4.7 --- .../src/mcp/OrchestratorMcpService.test.ts | 120 ++++++++++++++++++ apps/server/src/mcp/OrchestratorMcpService.ts | 51 +++----- .../src/mcp/toolkits/project/handlers.test.ts | 1 + .../src/mcp/toolkits/project/handlers.ts | 6 + .../src/mcp/toolkits/thread/handlers.test.ts | 120 ++++++++++++++++++ .../src/mcp/toolkits/thread/handlers.ts | 13 ++ .../ThreadLaunchService.test.ts | 60 +++++++++ .../orchestration-v2/ThreadLaunchService.ts | 21 +++ .../ThreadManagementService.test.ts | 64 ++++++++++ .../ThreadManagementService.ts | 33 +++++ .../ThreadMessageIntake.test.ts | 70 ++++++++++ .../orchestration-v2/ThreadMessageIntake.ts | 22 ++++ apps/server/src/peer/RemoteDelegation.ts | 6 +- .../server/src/peer/placementEvidence.test.ts | 53 ++++++++ apps/server/src/peer/placementEvidence.ts | 3 +- apps/server/src/provider/servedModel.ts | 75 +++++++++++ .../ScheduledTaskService.test.ts | 82 ++++++++++++ .../scheduledTasks/ScheduledTaskService.ts | 10 ++ apps/server/src/ws.ts | 5 +- 19 files changed, 776 insertions(+), 39 deletions(-) create mode 100644 apps/server/src/mcp/toolkits/thread/handlers.test.ts create mode 100644 apps/server/src/peer/placementEvidence.test.ts create mode 100644 apps/server/src/provider/servedModel.ts diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts index 97907e2d50b2c..e4ef871360231 100644 --- a/apps/server/src/mcp/OrchestratorMcpService.test.ts +++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts @@ -2573,6 +2573,126 @@ describe("OrchestratorMcpService provider resolution", () => { }), ); + it.effect("refuses a Grok model on claudeAgent and accepts a model that instance serves", () => + Effect.gen(function* () { + const claudeInstanceId = ProviderInstanceId.make("claudeAgent"); + const claude = providerSnapshot({ + instanceId: claudeInstanceId, + driver: ProviderDriverKind.make("claudeAgent"), + model: "claude-opus", + }); + const dispatched = yield* Ref.make< + ReadonlyArray<{ modelSelection?: { instanceId: string; model: string } }> + >([]); + let delegated = false; + const task = { + id: taskId, + threadId: parentThreadId, + runId: parentRunId, + parentNodeId, + origin: "app_owned", + createdBy: "agent", + driver: ProviderDriverKind.make("claudeAgent"), + providerInstanceId: claudeInstanceId, + providerThreadId: null, + childThreadId, + nativeTaskRef: null, + prompt: "Summarize the diff.", + title: null, + model: "claude-opus", + status: "running", + result: null, + startedAt: null, + completedAt: null, + }; + const layerDependencies = Layer.mergeAll( + NodeServices.layer, + NodeCrypto.layer, + Layer.mock(ThreadManagementService.ThreadManagementService)({ + hasReceipt: () => Effect.succeed(false), + getThreadRecords: (threadId) => + Effect.succeed( + threadId === parentThreadId + ? parentProjection(delegated ? [task] : []) + : childProjection, + ), + dispatch: (command) => + Ref.update(dispatched, (commands) => [...commands, command as never]).pipe( + Effect.andThen( + Effect.sync(() => { + delegated = true; + }), + ), + Effect.as({ + sequence: 1, + storedEvents: [ + { + sequence: 1, + commandId: null, + event: { type: "subagent.updated", payload: task }, + }, + ], + } as never), + ), + }), + ServerSettings.layerTest(), + providerRegistryLayer([ + providerSnapshot({ + instanceId: codexInstanceId, + driver: ProviderDriverKind.make("codex"), + model: "gpt-5.4", + }), + { + ...claude, + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + }, + ]), + adapterRegistryLayer([codexInstanceId, claudeInstanceId]), + Layer.mock(ProjectService.ProjectService)({}), + Layer.mock(SecretRequests.SecretRequests)({}), + Layer.mock(RemoteDelegation.RemoteDelegation)({}), + Layer.mock(ScheduledTaskService.ScheduledTaskService)({}), + ); + + yield* Effect.gen(function* () { + const service = yield* OrchestratorMcpService.OrchestratorMcpService; + const refused = yield* service + .delegateTask(scope, { + task: "Summarize the diff.", + target: { providerInstanceId: claudeInstanceId, model: "grok/grok-4.7" }, + mode: "async", + clientRequestId: "delegate-grok-on-claude", + }) + .pipe(Effect.flip); + assert.equal(refused.code, "model_unavailable"); + assert.include(refused.message, "grok/grok-4.7"); + assert.include(refused.message, "claudeAgent"); + assert.include(refused.message, "claude-opus"); + assert.equal((yield* Ref.get(dispatched)).length, 0); + + const accepted = yield* service.delegateTask(scope, { + task: "Summarize the diff.", + target: { providerInstanceId: claudeInstanceId, model: "Opus" }, + mode: "async", + clientRequestId: "delegate-opus-on-claude", + }); + assert.equal(accepted.status, "running"); + const commands = yield* Ref.get(dispatched); + assert.equal(commands.length, 1); + assert.equal(commands[0]?.modelSelection?.instanceId, claudeInstanceId); + assert.equal(commands[0]?.modelSelection?.model, "Opus"); + }).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies)))); + }), + ); + it.effect("driver-only delegation skips an instance the project turned off", () => Effect.gen(function* () { const altInstanceId = ProviderInstanceId.make("codex-alt"); diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts index 800e8cbb3ba9d..ffbedbd044462 100644 --- a/apps/server/src/mcp/OrchestratorMcpService.ts +++ b/apps/server/src/mcp/OrchestratorMcpService.ts @@ -124,6 +124,7 @@ import { isSnoozed } from "../orchestration-v2/ThreadSettlementService.ts"; import { userFacingDispatchErrorMessage } from "../orchestration-v2/UserFacingErrors.ts"; import * as ProjectService from "../project/ProjectService.ts"; import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { findServedModel, unservedModelMessage } from "../provider/servedModel.ts"; import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts"; import * as ServerSettings from "../serverSettings.ts"; import { @@ -369,42 +370,8 @@ function listCapabilityModels(input: { return { listed, omitted: visible.length - listed.length }; } -/** Names advertised slugs to retry with: same last `/` segment first, else a short list. */ -function advertisedModelsHint(models: ReadonlyArray, requested: string) { - const lastSegment = (slug: string) => slug.slice(slug.lastIndexOf("/") + 1).toLowerCase(); - const wanted = lastSegment(requested); - const close = models.filter((model) => lastSegment(model.slug) === wanted); - if (close.length > 0) { - return `Did you mean ${close - .slice(0, LISTED_MODEL_LIMIT) - .map((model) => model.slug) - .join(", ")}?`; - } - const listed = models - .toSorted((a, b) => Number(a.isLegacy ?? false) - Number(b.isLegacy ?? false)) - .slice(0, LISTED_MODEL_LIMIT); - const omitted = models.length - listed.length; - return `Advertised models: ${listed.map((model) => model.slug).join(", ")}${ - omitted > 0 ? ` and ${omitted} more; orchestrator_capabilities with search finds them` : "" - }.`; -} - -/** Option ids and allowed values are all a delegating agent needs; labels are UI copy. */ -function capabilityModelOption(descriptor: ProviderOptionDescriptor): OrchestratorMcpModelOption { - const defaultValue = getProviderOptionCurrentValue(descriptor); - return { - id: descriptor.id, - values: - descriptor.type === "boolean" ? [false, true] : descriptor.options.map((choice) => choice.id), - ...(defaultValue === undefined ? {} : { default: defaultValue }), - }; -} - const advertisedModel = (provider: ServerProvider, model: string) => - provider.models.find((candidate) => candidate.slug === model) ?? - provider.models.find((candidate) => - candidate.aliases?.some((alias) => alias.toLowerCase() === model.toLowerCase()), - ); + findServedModel(provider.models, model); const withV = (version: string) => (version.startsWith("v") ? version : `v${version}`); @@ -421,12 +388,24 @@ export const requireAdvertisedModel = (provider: ServerProvider, model: string) failure( "model_unavailable", updateRequired === undefined - ? `Model ${model} is not advertised by provider ${provider.instanceId}. ${advertisedModelsHint(provider.models, model)}` + ? (unservedModelMessage(provider.instanceId, model, provider.models) ?? + `Model ${model} is not advertised by provider ${provider.instanceId}.`) : `Model ${model} needs provider ${provider.instanceId} at ${withV(updateRequired.minVersion)} or newer, but the detected CLI is ${detectedVersion === null ? "an unknown version" : withV(detectedVersion)}. Ask the user to update it or point the provider's binary path at a newer install.`, ), ); }; +/** Option ids and allowed values are all a delegating agent needs; labels are UI copy. */ +function capabilityModelOption(descriptor: ProviderOptionDescriptor): OrchestratorMcpModelOption { + const defaultValue = getProviderOptionCurrentValue(descriptor); + return { + id: descriptor.id, + values: + descriptor.type === "boolean" ? [false, true] : descriptor.options.map((choice) => choice.id), + ...(defaultValue === undefined ? {} : { default: defaultValue }), + }; +} + function providerConstraints( provider: ServerProvider | undefined, supportsOrchestrationV2: boolean, diff --git a/apps/server/src/mcp/toolkits/project/handlers.test.ts b/apps/server/src/mcp/toolkits/project/handlers.test.ts index 9572ed8d32793..e07f0610a4212 100644 --- a/apps/server/src/mcp/toolkits/project/handlers.test.ts +++ b/apps/server/src/mcp/toolkits/project/handlers.test.ts @@ -398,6 +398,7 @@ it.effect("a launch with a model its provider does not advertise creates no thre for (const [instanceId, model] of [ ["claudeAgent", "claude-unadvertised"], + ["claudeAgent", "grok/grok-4.7"], ["codex", "opus"], ] as const) { expect(yield* launchWith(instanceId, model)).toMatchObject({ diff --git a/apps/server/src/mcp/toolkits/project/handlers.ts b/apps/server/src/mcp/toolkits/project/handlers.ts index 6bd5b14690d74..c8e3aadead9e7 100644 --- a/apps/server/src/mcp/toolkits/project/handlers.ts +++ b/apps/server/src/mcp/toolkits/project/handlers.ts @@ -479,6 +479,12 @@ export const layer = McpToolAccess.toLayer(ProjectToolkit, { }); } // The administrator's ceiling refuses the mode; say so rather than "unavailable". + if (error._tag === "ThreadLaunchError" && error.operation === "reject-model") { + return new OrchestratorMcpFailure({ + code: "model_unavailable", + message: error.message, + }); + } if (error._tag === "ThreadLaunchError" && isAboveCeilingError(error.cause)) { return new OrchestratorMcpFailure({ code: "invalid_request", diff --git a/apps/server/src/mcp/toolkits/thread/handlers.test.ts b/apps/server/src/mcp/toolkits/thread/handlers.test.ts new file mode 100644 index 0000000000000..3852f88c19bd8 --- /dev/null +++ b/apps/server/src/mcp/toolkits/thread/handlers.test.ts @@ -0,0 +1,120 @@ +import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts"; +import { expect, it } from "@effect/vitest"; +import { + EnvironmentId, + ProjectId, + ProviderDriverKind, + ProviderInstanceId, + ThreadId, + type OrchestrationV2ServerCommand, + type ServerProvider, +} from "@t3tools/contracts"; +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Stream from "effect/Stream"; + +import * as ThreadManagement from "../../../orchestration-v2/ThreadManagementService.ts"; +import * as McpInvocationContext from "../../McpInvocationContext.ts"; +import * as McpToolAccess from "../../McpToolAccess.ts"; +import * as ThreadHandlers from "./handlers.ts"; +import { ThreadToolkit } from "./tools.ts"; + +const claude = ProviderInstanceId.make("claudeAgent"); +const threadId = ThreadId.make("thread:configure-model"); +const provider = { + instanceId: claude, + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], +} as ServerProvider; + +it.effect("thread configure refuses a Grok model on claudeAgent and accepts a served model", () => + Effect.gen(function* () { + const dispatched: OrchestrationV2ServerCommand[] = []; + const shell = { + id: threadId, + projectId: ProjectId.make("project:configure-model"), + providerInstanceId: claude, + modelSelection: { instanceId: claude, model: "claude-opus" }, + runtimeMode: "full-access", + interactionMode: "default", + deletedAt: null, + }; + const dependencies = Layer.mergeAll( + Layer.mock(ProviderRegistry.ProviderRegistry)({ + getProviders: Effect.succeed([provider]), + }), + Layer.succeed(McpInvocationContext.McpInvocationContext, { + environmentId: EnvironmentId.make("environment"), + requestNamespace: "client:configure-model", + thread: undefined, + client: { sessionId: "session-1", label: "Codex", access: "full-access" }, + issuedAt: 0, + capabilities: new Set(["orchestration" as const]), + }), + Layer.mock(ThreadManagement.ThreadManagementService)({ + getThreadShell: () => Effect.succeed(shell as never), + getProjectThreadRecords: () => Effect.succeed({ thread: shell } as never), + dispatch: (command) => + Effect.sync(() => { + dispatched.push(command); + return { sequence: dispatched.length, storedEvents: [] } as never; + }), + }), + NodeCrypto.layer, + ); + const toolkit = yield* ThreadToolkit.pipe( + Effect.provide( + McpToolAccess.HandlersLayer.layer(ThreadHandlers.layer).pipe(Layer.provide(dependencies)), + ), + ); + const configure = (model: string) => + toolkit + .handle("t3_thread_configure", { + threadId, + modelSelection: { instanceId: claude, model }, + }) + .pipe( + Stream.unwrap, + Stream.runCollect, + Effect.map((result) => result.at(-1)?.result), + Effect.provide(dependencies), + ); + + const refused = yield* configure("grok/grok-4.7"); + expect(refused).toMatchObject({ + code: "model_unavailable", + message: expect.stringContaining("claude-opus"), + }); + expect(refused).toMatchObject({ + message: expect.stringContaining( + "Model grok/grok-4.7 is not advertised by provider claudeAgent.", + ), + }); + expect(dispatched).toHaveLength(0); + + expect(yield* configure("Opus")).toMatchObject({ sequence: 1 }); + expect(dispatched).toMatchObject([ + { + type: "thread.model-selection.set", + modelSelection: { instanceId: claude, model: "Opus" }, + }, + ]); + }), +); diff --git a/apps/server/src/mcp/toolkits/thread/handlers.ts b/apps/server/src/mcp/toolkits/thread/handlers.ts index 2b7fb836a7b69..4a4545b3d5e84 100644 --- a/apps/server/src/mcp/toolkits/thread/handlers.ts +++ b/apps/server/src/mcp/toolkits/thread/handlers.ts @@ -8,6 +8,7 @@ import { type OrchestrationV2Command, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; import { modelSelectionCommandType } from "@t3tools/shared/model"; import { topOfPinnedRunOrderKey } from "@t3tools/shared/pinOrderKey"; @@ -25,6 +26,8 @@ import * as ThreadSearch from "../../../orchestration-v2/ThreadSearch.ts"; import * as ScheduledTasks from "../../../scheduledTasks/ScheduledTaskService.ts"; import { queuedRunsInDeliveryOrder } from "../../../orchestration-v2/QueuedRunOrder.ts"; import { ThreadToolkit } from "./tools.ts"; +import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts"; +import { refuseUnservedModel } from "../../../provider/servedModel.ts"; function queueEntry( projection: Pick, @@ -236,6 +239,16 @@ export const layer = McpToolAccess.toLayer(ThreadToolkit, { threads, projection: { thread }, } = yield* readThread(input.threadId); + const registry = yield* Effect.serviceOption(ProviderRegistry.ProviderRegistry); + const detail = Option.isNone(registry) + ? undefined + : refuseUnservedModel(yield* registry.value.getProviders, modelSelection); + if (detail !== undefined) { + return yield* new OrchestratorMcpFailure({ + code: "model_unavailable", + message: detail, + }); + } const type = modelSelectionCommandType(thread.providerInstanceId, modelSelection); const result = yield* threads .dispatch({ type, threadId: thread.id, commandId: yield* newCommandId(), modelSelection }) diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts index 42e214b8a0f53..8ac6935542014 100644 --- a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts @@ -365,6 +365,66 @@ function launchInput(input: { }; } +const claudeCatalog = { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready" as const, + version: "test", + auth: { status: "authenticated" as const }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], +} as ServerProvider; + +it.effect( + "refuses a Grok model on claudeAgent before launch and accepts an advertised alias", + () => { + const harness = makeHarness({ + adapters: [adapter, claudeAdapter], + providers: [claudeCatalog], + }); + return Effect.gen(function* () { + const launches = yield* ThreadLaunch.ThreadLaunchService; + const refused = yield* launches + .launch({ + ...launchInput({ command: "reject-grok", thread: "thread:reject-grok" }), + modelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "grok/grok-4.7", + }, + }) + .pipe(Effect.flip); + assert.equal(refused._tag, "ThreadLaunchError"); + if (refused._tag !== "ThreadLaunchError") return; + assert.equal(refused.operation, "reject-model"); + assert.include(refused.message, "grok/grok-4.7"); + assert.include(refused.message, "claudeAgent"); + assert.include(refused.message, "claude-opus"); + + const accepted = yield* launches.launch({ + ...launchInput({ command: "accept-opus", thread: "thread:accept-opus" }), + modelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "Opus", + }, + }); + assert.equal(accepted.projection.thread.modelSelection.instanceId, "claudeAgent"); + assert.equal(accepted.projection.thread.modelSelection.model, "Opus"); + }).pipe(Effect.provide(harness.layer)); + }, +); + it.effect.each( (["new", "existing"] as const).flatMap((target) => (["user", "agent"] as const).map((createdBy) => ({ target, createdBy })), diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.ts index c0045f7aa8058..6a4e38dcf1cc3 100644 --- a/apps/server/src/orchestration-v2/ThreadLaunchService.ts +++ b/apps/server/src/orchestration-v2/ThreadLaunchService.ts @@ -52,6 +52,7 @@ import * as ProjectService from "../project/ProjectService.ts"; import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts"; import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { refuseUnservedModel } from "../provider/servedModel.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as TextGeneration from "../textGeneration/TextGeneration.ts"; import * as CommandReceiptStore from "./CommandReceiptStore.ts"; @@ -156,6 +157,7 @@ export class ThreadLaunchError extends Schema.TaggedError()( "dispatch-message", "release-run", "fail-run", + "reject-model", ]), commandId: CommandId, projectId: ProjectId, @@ -164,6 +166,10 @@ export class ThreadLaunchError extends Schema.TaggedError()( }, ) { override get message(): string { + if (this.operation === "reject-model") { + const cause = this.cause; + return cause instanceof Error ? cause.message : String(cause); + } return `Thread launch ${this.commandId} failed during ${this.operation}.`; } } @@ -1223,6 +1229,21 @@ const make = Effect.gen(function* () { instanceId: input.modelSelection.instanceId, launch: true, }); + if (Option.isNone(launchReceipt)) { + const detail = refuseUnservedModel( + yield* providerRegistry.getProviders, + input.modelSelection, + ); + if (detail !== undefined) { + return yield* new ThreadLaunchError({ + operation: "reject-model", + commandId: input.commandId, + projectId: input.projectId, + ...(input.threadId === undefined ? {} : { threadId: input.threadId }), + cause: new Error(detail), + }); + } + } return yield* Effect.gen(function* () { // Recover ids from accepted launch receipts before allocating; retries have no client id and new ids collide with receipts. const reusableLaunchReceipt = diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.test.ts b/apps/server/src/orchestration-v2/ThreadManagementService.test.ts index 97ab0a8db1657..f142f1338069e 100644 --- a/apps/server/src/orchestration-v2/ThreadManagementService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadManagementService.test.ts @@ -36,7 +36,9 @@ import * as CommandReceiptStore from "./CommandReceiptStore.ts"; import * as Orchestrator from "./Orchestrator.ts"; import * as ProviderSessionManager from "./ProviderSessionManager.ts"; import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; import * as ThreadManagementService from "./ThreadManagementService.ts"; +import type { ServerProvider } from "@t3tools/contracts"; import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts"; import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts"; import { @@ -211,6 +213,68 @@ it.effect( }, ); +it.effect( + "the dispatch chokepoint refuses a Grok model on claudeAgent and accepts a model that instance serves", + () => { + const threadId = ThreadId.make("thread:thread-management:chokepoint"); + const instanceId = ProviderInstanceId.make("claudeAgent"); + const dispatched: Array = []; + const provider = { + instanceId, + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as ServerProvider; + const layerTest = layerDispatchChokepointTest(ServerSettings.layerTest())(dispatched).pipe( + Layer.provideMerge(ProviderRegistryMock.layer([provider])), + ); + const send = (commandId: string, model: string) => + ThreadManagementService.ThreadManagementService.pipe( + Effect.flatMap((threads) => + threads.dispatch({ + type: "message.dispatch", + commandId: CommandId.make(commandId), + threadId, + messageId: MessageId.make(`message:${commandId}`), + text: "Continue.", + attachments: [], + modelSelection: { instanceId, model }, + dispatchMode: { type: "queue_after_active" }, + createdBy: "user", + creationSource: "web", + }), + ), + ); + + return Effect.gen(function* () { + const refused = yield* send("command:grok-on-claude", "grok/grok-4.7").pipe(Effect.flip); + expect(refused).toBeInstanceOf(Orchestrator.OrchestratorCommandRejectedError); + expect(String(refused.cause)).toContain("grok/grok-4.7"); + expect(String(refused.cause)).toContain("claudeAgent"); + expect(String(refused.cause)).toContain("claude-opus"); + expect(dispatched).toEqual([]); + + yield* send("command:opus-on-claude", "claude-opus"); + expect(dispatched).toEqual(["message.dispatch"]); + }).pipe(Effect.provide(layerTest)); + }, +); + it.effect.each([ { label: "fails a send that starts a turn", running: false }, { label: "still steers a running turn", running: true }, diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.ts b/apps/server/src/orchestration-v2/ThreadManagementService.ts index efeb3a99f71a5..eddf25b104b82 100644 --- a/apps/server/src/orchestration-v2/ThreadManagementService.ts +++ b/apps/server/src/orchestration-v2/ThreadManagementService.ts @@ -72,6 +72,8 @@ import { DispatchModeLimit, exceededDispatchModeLimit } from "./DispatchModeLimi import { projectTurnItemForDetail } from "./WireProjection.ts"; import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts"; import * as ServerSettings from "../serverSettings.ts"; +import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { modelSelectionFromCommand, refuseUnservedModel } from "../provider/servedModel.ts"; import { ThreadWorktreeRestore } from "../workspace/restoreMissingWorktree.ts"; export type ThreadManagementSendMode = "auto" | "queue" | "steer" | "restart"; @@ -931,9 +933,40 @@ const make = Effect.gen(function* () { } }; + const assertModelServed = (command: OrchestrationV2ServerCommand) => { + const selection = modelSelectionFromCommand(command); + if (selection === undefined) return Effect.void; + return receipts.getByCommandId(command.commandId).pipe( + Effect.orElseSucceed(() => Option.none()), + Effect.flatMap((receipt) => + Option.isSome(receipt) + ? Effect.void + : Effect.serviceOption(ProviderRegistry.ProviderRegistry).pipe( + Effect.flatMap((registry) => + Option.isNone(registry) + ? Effect.void + : registry.value.getProviders.pipe( + Effect.flatMap((providers) => { + const detail = refuseUnservedModel(providers, selection); + return detail === undefined + ? Effect.void + : new Orchestrator.OrchestratorCommandRejectedError({ + commandId: command.commandId, + commandType: command.type, + cause: detail, + }); + }), + ), + ), + ), + ), + ); + }; + const dispatch: ThreadManagementServiceShape["dispatch"] = (command) => ensureCommandTranscripts(command).pipe( Effect.andThen(assertDispatchTargetEnabled(command)), + Effect.andThen(assertModelServed(command)), Effect.andThen(orchestrator.dispatch(command)), ); diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts index a92cdd22aa515..3cb006f34d6b9 100644 --- a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts +++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts @@ -10,6 +10,8 @@ import { EventId, GuestMessageId, MessageId, + ProviderDriverKind, + ProviderInstanceId, RunId, RuntimeRequestId, ThreadId, @@ -17,6 +19,7 @@ import { type OrchestrationV2Command, type OrchestrationV2ServerCommand, type OrchestrationV2StoredEvent, + type ServerProvider, type UserInputAttachments, } from "@t3tools/contracts"; import * as DateTime from "effect/DateTime"; @@ -31,8 +34,10 @@ import * as ServerConfig from "../config.ts"; import * as ServerSettings from "../serverSettings.ts"; import { OrchestratorCommandPreviouslyRejectedError, + OrchestratorCommandRejectedError, OrchestratorDispatchError, } from "./Orchestrator.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; import * as ThreadManagementService from "./ThreadManagementService.ts"; import { dispatchCommand } from "./ThreadMessageIntake.ts"; @@ -475,3 +480,68 @@ it.effect("refuses a queued edit that keeps a file another edit already deleted" expect(captured).toHaveLength(2); }).pipe(Effect.provide(layerIntakeTest)), ); + +const claudeCatalog = { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], +} as ServerProvider; + +it.effect( + "refuses a Grok model on claudeAgent before a send and accepts a model that instance serves", + () => + Effect.gen(function* () { + const captured: OrchestrationV2ServerCommand[] = []; + const layer = Layer.mergeAll( + Layer.mock(ThreadManagementService.ThreadManagementService)({ + hasReceipt: () => Effect.succeed(false), + dispatch: layerFailingDispatchHandler(captured), + }), + ProviderRegistryMock.layer([claudeCatalog]), + ); + const send = (commandId: string, model: string) => + dispatchCommand({ + type: "message.dispatch", + commandId: CommandId.make(commandId), + threadId: ThreadId.make("thread-model-guard"), + messageId: MessageId.make(`message-${commandId}`), + text: "Continue.", + attachments: [], + modelSelection: { instanceId: ProviderInstanceId.make("claudeAgent"), model }, + dispatchMode: { type: "queue_after_active" }, + createdBy: "user", + creationSource: "web", + }).pipe(Effect.provide(layer)); + + const refused = yield* send("send-grok", "grok/grok-4.7").pipe(Effect.flip); + expect(refused).toBeInstanceOf(OrchestratorCommandRejectedError); + expect(String(refused.cause)).toContain("grok/grok-4.7"); + expect(String(refused.cause)).toContain("claudeAgent"); + expect(String(refused.cause)).toContain("claude-opus"); + expect(captured).toHaveLength(0); + + const accepted = yield* send("send-opus", "claude-opus").pipe(Effect.result); + expect(accepted._tag).toBe("Failure"); + expect(captured).toHaveLength(1); + expect(captured[0]).toMatchObject({ + type: "message.dispatch", + modelSelection: { instanceId: "claudeAgent", model: "claude-opus" }, + }); + }).pipe(Effect.provide(layerIntakeTest)), +); diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts index 6e9fd503baec5..3c09a2a24a90e 100644 --- a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts +++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts @@ -11,6 +11,10 @@ import * as Orchestrator from "./Orchestrator.ts"; import * as AttachmentClaims from "./AttachmentClaims.ts"; import * as ThreadLaunch from "./ThreadLaunchService.ts"; import * as ThreadManagement from "./ThreadManagementService.ts"; +import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { modelSelectionFromCommand, refuseUnservedModel } from "../provider/servedModel.ts"; +import * as Option from "effect/Option"; +import { OrchestratorCommandRejectedError } from "./Orchestrator.ts"; // These failures precede commitCommand; generic dispatch errors can follow commits and remain ambiguous. function dispatchWasNotAccepted( @@ -91,6 +95,23 @@ export const dispatchCommand = Effect.fn("ThreadMessageIntake.dispatchCommand")( const command = incoming.type === "message.dispatch" ? yield* withGuestAttachments(incoming) : incoming; const threads = yield* ThreadManagement.ThreadManagementService; + const selection = modelSelectionFromCommand(command); + if ( + selection !== undefined && + !(yield* threads.hasReceipt(command.commandId).pipe(Effect.orElseSucceed(() => false))) + ) { + const registry = yield* Effect.serviceOption(ProviderRegistry.ProviderRegistry); + if (Option.isSome(registry)) { + const detail = refuseUnservedModel(yield* registry.value.getProviders, selection); + if (detail !== undefined) { + return yield* new OrchestratorCommandRejectedError({ + commandId: command.commandId, + commandType: command.type, + cause: detail, + }); + } + } + } if (command.type === "runtime-request.respond" && command.attachmentsByQuestionId) { const config = yield* ServerConfig.ServerConfig; const incomingByQuestionId = command.attachmentsByQuestionId; @@ -277,6 +298,7 @@ export const launchThread = Effect.fn("ThreadMessageIntake.launchThread")(functi const notAccepted = error.operation === "resolve-project" || error.operation === "read-receipt" || + error.operation === "reject-model" || ((error.operation === "create-thread" || error.operation === "dispatch-message") && (isOrchestratorError(error.cause) || isThreadManagementError(error.cause)) && // Projection errors under create-thread can occur after the message commit. diff --git a/apps/server/src/peer/RemoteDelegation.ts b/apps/server/src/peer/RemoteDelegation.ts index ed4ea992a9749..75dbe265c79f9 100644 --- a/apps/server/src/peer/RemoteDelegation.ts +++ b/apps/server/src/peer/RemoteDelegation.ts @@ -27,6 +27,7 @@ import { type RuntimeMode, type ThreadId, } from "@t3tools/contracts"; +import { findServedModel } from "../provider/servedModel.ts"; import { chooseThreadPlacement, type ThreadPlacementCandidate, @@ -271,7 +272,10 @@ export const runsModel = ( (provider) => provider.providerInstanceId === requested.modelSelection.instanceId && provider.canRunChildTask && - provider.models.some((model) => model.id === requested.modelSelection.model) && + findServedModel( + provider.models.map((model) => ({ slug: model.id })), + requested.modelSelection.model, + ) !== undefined && (provider.runtimeModes === undefined || provider.runtimeModes.includes(requested.runtimeMode)), ); diff --git a/apps/server/src/peer/placementEvidence.test.ts b/apps/server/src/peer/placementEvidence.test.ts new file mode 100644 index 0000000000000..01f577c944e79 --- /dev/null +++ b/apps/server/src/peer/placementEvidence.test.ts @@ -0,0 +1,53 @@ +import { assert, it } from "@effect/vitest"; +import { + ProjectId, + ProviderDriverKind, + ProviderInstanceId, + type ServerProvider, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; +import * as ServerSettings from "../serverSettings.ts"; +import { hereEvidence } from "./placementEvidence.ts"; + +const provider = { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + aliases: ["Opus"], + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], +} as ServerProvider; + +it.effect("placement evidence rejects a Grok model on claudeAgent and accepts a served alias", () => + Effect.gen(function* () { + const projectId = ProjectId.make("project:placement-model"); + const evidence = (model: string) => + hereEvidence({ + projectId, + modelSelection: { instanceId: ProviderInstanceId.make("claudeAgent"), model }, + runtimeMode: "full-access", + }); + assert.equal((yield* evidence("grok/grok-4.7")).modelAvailable, false); + assert.equal((yield* evidence("Opus")).modelAvailable, true); + }).pipe( + Effect.provide( + Layer.mergeAll(ProviderRegistryMock.layer([provider]), ServerSettings.layerTest()), + ), + ), +); diff --git a/apps/server/src/peer/placementEvidence.ts b/apps/server/src/peer/placementEvidence.ts index 763f895236832..92fd2fd8ed0b0 100644 --- a/apps/server/src/peer/placementEvidence.ts +++ b/apps/server/src/peer/placementEvidence.ts @@ -9,6 +9,7 @@ import * as Effect from "effect/Effect"; import * as Option from "effect/Option"; import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { findServedModel } from "../provider/servedModel.ts"; import * as HostResources from "../resourceTelemetry/HostResources.ts"; import * as ServerSettings from "../serverSettings.ts"; @@ -34,7 +35,7 @@ export const hereEvidence = Effect.fn("placement.hereEvidence")(function* (input provider.enabled && isProviderAvailable(provider) && resolveProjectProviderInstanceEnabled(settings, input.projectId, provider.instanceId) && - provider.models.some((model) => model.slug === input.modelSelection.model) && + findServedModel(provider.models, input.modelSelection.model) !== undefined && (provider.supportedRuntimeModes === undefined || provider.supportedRuntimeModes.length === 0 || provider.supportedRuntimeModes.includes(input.runtimeMode)), diff --git a/apps/server/src/provider/servedModel.ts b/apps/server/src/provider/servedModel.ts new file mode 100644 index 0000000000000..c9d979ff53e80 --- /dev/null +++ b/apps/server/src/provider/servedModel.ts @@ -0,0 +1,75 @@ +import type { + ModelSelection, + OrchestrationV2ServerCommand, + ServerProvider, + ServerProviderModel, +} from "@t3tools/contracts"; + +const LISTED_MODEL_LIMIT = 8; + +type ListedModel = Pick; + +export function findServedModel>( + models: ReadonlyArray, + model: string, +): Model | undefined { + return ( + models.find((candidate) => candidate.slug === model) ?? + models.find((candidate) => + candidate.aliases?.some((alias) => alias.toLowerCase() === model.toLowerCase()), + ) + ); +} + +export function servedModelsHint(models: ReadonlyArray, requested: string): string { + const lastSegment = (slug: string) => slug.slice(slug.lastIndexOf("/") + 1).toLowerCase(); + const wanted = lastSegment(requested); + const close = models.filter((model) => lastSegment(model.slug) === wanted); + if (close.length > 0) { + return `Did you mean ${close + .slice(0, LISTED_MODEL_LIMIT) + .map((model) => model.slug) + .join(", ")}?`; + } + const listed = models + .toSorted((a, b) => Number(a.isLegacy ?? false) - Number(b.isLegacy ?? false)) + .slice(0, LISTED_MODEL_LIMIT); + const omitted = models.length - listed.length; + return `Advertised models: ${listed.map((model) => model.slug).join(", ")}${ + omitted > 0 ? ` and ${omitted} more; orchestrator_capabilities with search finds them` : "" + }.`; +} + +export function unservedModelMessage( + instanceId: string, + model: string, + models: ReadonlyArray, +): string | undefined { + if (models.length === 0 || findServedModel(models, model) !== undefined) return undefined; + return `Model ${model} is not advertised by provider ${instanceId}. ${servedModelsHint(models, model)}`; +} + +export function refuseUnservedModel( + providers: ReadonlyArray>, + selection: Pick, +): string | undefined { + const provider = providers.find((candidate) => candidate.instanceId === selection.instanceId); + if (provider === undefined) return undefined; + return unservedModelMessage(provider.instanceId, selection.model, provider.models); +} + +export function modelSelectionFromCommand( + command: OrchestrationV2ServerCommand, +): ModelSelection | undefined { + switch (command.type) { + case "thread.create": + case "thread.model-selection.set": + case "provider.switch": + case "delegated_task.request": + return command.modelSelection; + case "message.dispatch": + return command.modelSelection; + default: + return undefined; + } +} diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts index 1335e369484a5..af5776fdb3596 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts @@ -6,8 +6,10 @@ import { assert, it, vi } from "@effect/vitest"; import { CommandId, ProjectId, + ProviderDriverKind, ProviderInstanceId, ScheduledTaskError, + type ServerProvider, ScheduledTaskId, type ScheduledTaskUpsertInput, SecretRef, @@ -36,6 +38,7 @@ import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; import * as SqlitePersistence from "../persistence/Sqlite.ts"; import * as ScheduledTaskService from "./ScheduledTaskService.ts"; import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const isScheduledTaskError = Schema.is(ScheduledTaskError); @@ -1067,3 +1070,82 @@ it.effect("a run interrupted right after it reserves the task does not block the }).pipe(Effect.provide(layer)); }).pipe(Effect.provide(SqlitePersistence.layerMemory)), ); + +it.effect( + "refuses a Grok model on claudeAgent when a schedule is saved and accepts a served model", + () => + Effect.gen(function* () { + const provider = { + instanceId: ProviderInstanceId.make("claudeAgent"), + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "claude-opus", + name: "Opus", + isCustom: false, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as ServerProvider; + const layer = ScheduledTaskService.layer.pipe( + Layer.provide( + Layer.mergeAll( + ManagedPolicy.layerTest(), + Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), + Layer.mock(ThreadManagementService.ThreadManagementService)({}), + Layer.mock(SecretRequests.SecretRequests)({}), + Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ + namedProjectsRoot: "/projects", + isScratchProject: () => Effect.succeed(false), + }), + NodeCrypto.layer, + Scheduler.layer, + ), + ), + ); + yield* Effect.gen(function* () { + const service = yield* ScheduledTaskService.ScheduledTaskService; + const input = { + title: "Nightly", + prompt: "Check the lane.", + enabled: false, + schedule: { type: "interval" as const, everyMs: 60_000 }, + projectId: ProjectId.make("project:test"), + workspaceStrategy: { type: "root" as const }, + runtimeMode: "full-access" as const, + interactionMode: "default" as const, + }; + const refused = yield* service + .upsert({ + ...input, + modelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "grok/grok-4.7", + }, + }) + .pipe(Effect.flip); + assert.isTrue(isScheduledTaskError(refused)); + assert.include(refused.message, "grok/grok-4.7"); + assert.include(refused.message, "claudeAgent"); + assert.include(refused.message, "claude-opus"); + + const { task } = yield* service.upsert({ + ...input, + modelSelection: { + instanceId: ProviderInstanceId.make("claudeAgent"), + model: "claude-opus", + }, + }); + assert.equal(task.modelSelection.model, "claude-opus"); + assert.equal(task.modelSelection.instanceId, "claudeAgent"); + }).pipe(Effect.provide(Layer.mergeAll(layer, ProviderRegistryMock.layer([provider])))); + }).pipe(Effect.provide(SqlitePersistence.layerMemory)), +); diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.ts index 9ed134be2da5a..ac742ee7d0dba 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.ts @@ -50,6 +50,8 @@ import * as Stream from "effect/Stream"; import * as SqlClient from "effect/sql/SqlClient"; import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts"; +import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; +import { refuseUnservedModel } from "../provider/servedModel.ts"; import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; import * as Metrics from "../observability/Metrics.ts"; import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts"; @@ -1427,6 +1429,14 @@ export const layer = Layer.effect( ScheduledTaskId.make( input.commandId ? `scheduled-task:${input.commandId}` : `scheduled-task:${uuid}`, ); + const registry = yield* Effect.serviceOption(ProviderRegistry.ProviderRegistry); + if (Option.isSome(registry)) { + const detail = refuseUnservedModel( + yield* registry.value.getProviders, + input.modelSelection, + ); + if (detail !== undefined) return yield* taskError(detail, { taskId: id }); + } // Look up by the *resolved* id so idempotent creates (commandId replays) // keep their run history, and so real load failures propagate instead // of silently resetting an existing row. diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts index 0a621e39cd31a..3a0ee0f6cb77d 100644 --- a/apps/server/src/ws.ts +++ b/apps/server/src/ws.ts @@ -2341,7 +2341,10 @@ export const layerWsRpc = ( new OrchestrationV2ThreadLaunchError({ commandId: input.commandId, projectId: input.projectId, - message: "Failed to launch thread", + message: + cause.operation === "reject-model" + ? cause.message + : "Failed to launch thread", cause, }), ServerRuntimeStartupError: (cause) => From 752450527a2a7547ac8e691aee124fc0cbe3c0ae Mon Sep 17 00:00:00 2001 From: nullStack65 <112618179+nullStack65@users.noreply.github.com> Date: Fri, 20 Nov 2026 05:50:02 +0000 Subject: [PATCH 2/2] fix(server): require the provider registry for the model guard A custom-only Codex catalog no longer refuses built-in models, and launch, send, and schedule paths fail the check when the registry is missing instead of skipping it. Model: grok-4.7 Task: CLO-946 refuse a model the provider instance does not serve Agent: magpie Lane: magpie Harness: t3/codex Model-family: Grok Model-generation: 4.7 Skills-SHA: 0540352af0d6f43bdeea39a8c4aad4660ab0ec55 Co-Authored-By: Grok 4.7 --- .../server/src/mcp/McpToolAccess.race.test.ts | 2 ++ .../src/mcp/OrchestratorMcpService.test.ts | 3 ++ ...OrchestratorMcpToolkit.integration.test.ts | 1 + apps/server/src/mcp/linkOrigin.test.ts | 2 ++ ...laudeAutomaticDelivery.integration.test.ts | 2 ++ .../DelegatedCompletionDelivery.test.ts | 3 ++ ...ProjectSettingsUpgrade.integration.test.ts | 2 ++ .../SteeringCompletion.integration.test.ts | 2 ++ .../ThreadLaunchService.test.ts | 35 +++++++++++++++++++ .../ThreadManagementService.test.ts | 20 ++++++++--- .../ThreadManagementService.ts | 29 +++++++-------- .../ThreadMessageIntake.test.ts | 1 + .../orchestration-v2/ThreadMessageIntake.ts | 21 ++++++----- .../src/orchestration-v2/ThreadStop.test.ts | 3 ++ .../ThreadTitleRegenerationService.test.ts | 2 ++ apps/server/src/orchestration-v2/http.test.ts | 2 ++ .../src/orchestration-v2/runtimeLayer.test.ts | 13 ++++++- apps/server/src/provider/servedModel.ts | 9 +++-- .../ScheduledTaskService.interval.test.ts | 2 ++ .../ScheduledTaskService.schedule.test.ts | 8 +++++ .../ScheduledTaskService.test.ts | 15 +++++++- .../scheduledTasks/ScheduledTaskService.ts | 14 ++++---- .../ScheduledTaskService.webhook.test.ts | 2 ++ apps/server/src/ws.ts | 1 + 24 files changed, 151 insertions(+), 43 deletions(-) diff --git a/apps/server/src/mcp/McpToolAccess.race.test.ts b/apps/server/src/mcp/McpToolAccess.race.test.ts index 523d8ad560967..f3740aa4fcc49 100644 --- a/apps/server/src/mcp/McpToolAccess.race.test.ts +++ b/apps/server/src/mcp/McpToolAccess.race.test.ts @@ -28,6 +28,7 @@ import * as McpHttpServer from "./McpHttpServer.ts"; import * as McpInvocationContext from "./McpInvocationContext.ts"; import * as McpToolAccess from "./McpToolAccess.ts"; import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const instanceId = ProviderInstanceId.make("codex"); const adapter = { @@ -182,6 +183,7 @@ it.layer(layerOrchestrator)("writesThreads against a mode raise", (it) => { }).pipe( Effect.provide( ThreadManagement.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(ServerSettings.layerTest()), Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))), ), diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts index e4ef871360231..e975ac85c06c7 100644 --- a/apps/server/src/mcp/OrchestratorMcpService.test.ts +++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts @@ -78,6 +78,7 @@ import * as OrchestratorMcpService from "./OrchestratorMcpService.ts"; import { resolveRuntimeMode } from "./delegatedTaskModes.ts"; import type { ProjectionRecordFilter } from "../orchestration-v2/ProjectionStore.ts"; import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const decodeTarget = Schema.decodeUnknownEffect(OrchestratorMcpTarget); @@ -2955,6 +2956,7 @@ describe("OrchestratorMcpService provider resolution", () => { }, }); const layerThreads = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provideMerge(layerOrchestrator), Layer.provide( LegacyV1ThreadImporter.layer.pipe( @@ -3137,6 +3139,7 @@ describe("OrchestratorMcpService provider resolution", () => { providerInstances: { [codexInstanceId]: { driver: "codex", enabled: true } }, }); const layerThreads = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provideMerge(layerOrchestrator), Layer.provide( LegacyV1ThreadImporter.layer.pipe( diff --git a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts index 2ec6e939927e4..681cba49aa799 100644 --- a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts +++ b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts @@ -241,6 +241,7 @@ describe("orchestrator MCP toolkit", () => { ).pipe( Layer.provide( ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(layerOrchestrator), Layer.provide(ServerSettings.layerTest()), Layer.provide( diff --git a/apps/server/src/mcp/linkOrigin.test.ts b/apps/server/src/mcp/linkOrigin.test.ts index 928fda0dd72f8..bd66ee28a6b17 100644 --- a/apps/server/src/mcp/linkOrigin.test.ts +++ b/apps/server/src/mcp/linkOrigin.test.ts @@ -48,6 +48,7 @@ import * as PeerForwarding from "../peer/PeerForwarding.ts"; import * as ThreadSearch from "../orchestration-v2/ThreadSearch.ts"; import * as PeerLinkRequests from "../peer/PeerLinkRequests.ts"; import * as PeerLinks from "../peer/PeerLinks.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; // A linked environment's session drives this one's real orchestrator through // its real T3 tools. What the link starts carries its origin, and the link @@ -73,6 +74,7 @@ const layerOrchestrator = Layer.mergeAll( ), ); const layerOrchestration = ThreadManagement.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))), Layer.provideMerge(Layer.merge(layerOrchestrator, ServerSettings.layerTest())), ); diff --git a/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts b/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts index 1fa7047aff428..114a30661bc8c 100644 --- a/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts +++ b/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts @@ -46,6 +46,7 @@ import * as ThreadManagementService from "./ThreadManagementService.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as ProviderReplayHarness from "./testkit/ProviderReplayHarness.ts"; import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const sessionId = "automatic-delivery-session"; const settings = Schema.decodeSync(ClaudeSettings)({}); @@ -353,6 +354,7 @@ it.effect.each(deliveries)( Layer.provide( Layer.mergeAll(NodeCrypto.layer, Scheduler.layer, SqlitePersistence.layerMemory), ), + Layer.provide(ProviderRegistryMock.layer()), ), ), ); diff --git a/apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts b/apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts index d40891b9a117a..4c0bed5c0c6a1 100644 --- a/apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts +++ b/apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts @@ -68,6 +68,7 @@ import * as ProviderContinuationRequests from "@t3tools/provider-core/server/Pro import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator"; import { PROVIDER_STOP_REASON_SIGNAL } from "@t3tools/provider-core/server/subagentProjection"; import * as ProviderContinuationService from "./ProviderContinuationService.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const layerPlatformTest = Layer.merge( Layer.mergeAll(NodeServices.layer, NodeCrypto.layer), @@ -89,6 +90,7 @@ const layerVcsDriverRegistryTest = VcsDriverRegistry.layer.pipe( Layer.provide(VcsProcess.layer), Layer.provide(layerServerConfig), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); const layerCheckpointStoreTest = CheckpointStore.layer.pipe( @@ -172,6 +174,7 @@ const layerTest = Layer.mergeAll( Layer.provide(ServerSettings.layerTest()), Layer.provide(layerTestProviderInstanceRegistry), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); // ProviderContinuationService consumes the orchestrator's continuation queue, as in production. diff --git a/apps/server/src/orchestration-v2/ProjectSettingsUpgrade.integration.test.ts b/apps/server/src/orchestration-v2/ProjectSettingsUpgrade.integration.test.ts index b27b6604b1435..be7cdb781326e 100644 --- a/apps/server/src/orchestration-v2/ProjectSettingsUpgrade.integration.test.ts +++ b/apps/server/src/orchestration-v2/ProjectSettingsUpgrade.integration.test.ts @@ -29,6 +29,7 @@ import * as VcsProcess from "../vcs/VcsProcess.ts"; import * as WorkspacePaths from "../workspace/WorkspacePaths.ts"; import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts"; import * as RuntimeLayer from "./runtimeLayer.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const projectId = ProjectId.make("project:upgrade"); const icon = { kind: "emoji", emoji: "🦊" } as const; @@ -171,6 +172,7 @@ const layerRuntime = (dbPath: string) => { }), ), Layer.provide(layerPlatform), + Layer.provide(ProviderRegistryMock.layer()), ); }; diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts index 11b36aeb148eb..99d544ec2c646 100644 --- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts +++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts @@ -40,6 +40,7 @@ import * as CommandReceiptStore from "./CommandReceiptStore.ts"; import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace"; import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const driver = ProviderDriverKind.make("codex"); const instanceId = ProviderInstanceId.make("codex"); @@ -3063,6 +3064,7 @@ it.effect("reports a restart that stops the running turn as restarted", () => }).pipe( Effect.provide( ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provideMerge(layer), Layer.provide(ServerSettings.layerTest()), Layer.provide( diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts index 8ac6935542014..6f845be7a5806 100644 --- a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts @@ -162,6 +162,7 @@ function makeHarness(options: HarnessOptions = {}) { Layer.provide(layerOrchestrator), Layer.provide(layerServerSettings), Layer.provide(layerReceipts), + Layer.provide(ProviderRegistryMock.layer(options.providers ?? [])), ); const layerOutbox = EffectOutbox.layer.pipe(Layer.provide(layerDatabase)); const createWorktree = vi.fn( @@ -425,6 +426,40 @@ it.effect( }, ); +it.effect("accepts a built-in Codex model when the catalog lists only custom models", () => { + const harness = makeHarness({ + providers: [ + { + instanceId: ProviderInstanceId.make("codex"), + driver: ProviderDriverKind.make("codex"), + enabled: true, + installed: true, + status: "ready", + version: "test", + auth: { status: "authenticated" }, + checkedAt: "2026-01-01T00:00:00.000Z", + models: [ + { + slug: "my-custom", + name: "My custom", + isCustom: true, + capabilities: null, + }, + ], + slashCommands: [], + skills: [], + } as ServerProvider, + ], + }); + return Effect.gen(function* () { + const launches = yield* ThreadLaunch.ThreadLaunchService; + const accepted = yield* launches.launch( + launchInput({ command: "accept-builtin", thread: "thread:accept-builtin" }), + ); + assert.equal(accepted.projection.thread.modelSelection.model, "gpt-5.1-codex"); + }).pipe(Effect.provide(harness.layer)); +}); + it.effect.each( (["new", "existing"] as const).flatMap((target) => (["user", "agent"] as const).map((createdBy) => ({ target, createdBy })), diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.test.ts b/apps/server/src/orchestration-v2/ThreadManagementService.test.ts index f142f1338069e..4dba426ab9975 100644 --- a/apps/server/src/orchestration-v2/ThreadManagementService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadManagementService.test.ts @@ -96,8 +96,10 @@ const layerReceiptsTest = CommandReceiptStore.layer.pipe( ); const layerDispatchChokepointTest = - (settingsLayer: ReturnType) => (dispatched: Array) => + (settingsLayer: ReturnType) => + (dispatched: Array, providers: ReadonlyArray = []) => ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer(providers)), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -240,9 +242,9 @@ it.effect( slashCommands: [], skills: [], } as ServerProvider; - const layerTest = layerDispatchChokepointTest(ServerSettings.layerTest())(dispatched).pipe( - Layer.provideMerge(ProviderRegistryMock.layer([provider])), - ); + const layerTest = layerDispatchChokepointTest(ServerSettings.layerTest())(dispatched, [ + provider, + ]); const send = (commandId: string, model: string) => ThreadManagementService.ThreadManagementService.pipe( Effect.flatMap((threads) => @@ -283,6 +285,7 @@ it.effect.each([ const threadId = ThreadId.make("thread:thread-management:worktree-gone"); const dispatched: Array = []; const layerTest = ThreadManagementService.layerWithLegacyImporter.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide( Layer.succeed(ThreadWorktreeRestore, { restore: () => @@ -387,6 +390,7 @@ it.effect("waitForThread follows a restart continuation instead of the cut run", const stored = (sequence: number, event: object) => ({ sequence, event: { threadId, ...event } }) as unknown as OrchestrationV2StoredEvent; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -464,6 +468,7 @@ it.effect("waitForThread can wait past an ended run for the thread's delegated w const stored = (sequence: number, event: object) => ({ sequence, event: { threadId, ...event } }) as unknown as OrchestrationV2StoredEvent; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -542,6 +547,7 @@ it.effect("waitForThread settles delegated work on a thread rolled back past its completedAt: DateTime.makeUnsafe(1_000), } as unknown as OrchestrationV2Run; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -595,6 +601,7 @@ it.effect("waitForThread returns the cut run once its continuation is declined", const declined = yield* Deferred.make(); let pending = true; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -690,6 +697,7 @@ it.effect.each([ }), } as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide( Layer.mergeAll( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -784,6 +792,7 @@ it.effect.each([ // The notification starts after the completed run was observed, before settlement commits. let raced = false; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -952,6 +961,7 @@ it.effect.each([ const teardowns: Array = []; const tornDown = yield* Deferred.make(); const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide( Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({ isLive: () => Effect.succeed(true), @@ -1033,6 +1043,7 @@ it.effect("Force stop refuses once a newer run has started, before killing anyth const threadId = ThreadId.make("thread:thread-management:force-stop-superseded"); let killed = false; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ @@ -1080,6 +1091,7 @@ it.effect( ]), ); const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({})), Layer.provide( Layer.mock(Orchestrator.OrchestratorV2)({ diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.ts b/apps/server/src/orchestration-v2/ThreadManagementService.ts index eddf25b104b82..0b57f9e18a988 100644 --- a/apps/server/src/orchestration-v2/ThreadManagementService.ts +++ b/apps/server/src/orchestration-v2/ThreadManagementService.ts @@ -665,6 +665,7 @@ const isForceStopThreadError = Schema.is(OrchestrationV2ForceStopThreadError); const INTENT_RECEIPT_TYPE = "intent.bind:"; const make = Effect.gen(function* () { + const providerRegistry = yield* ProviderRegistry.ProviderRegistry; const threadDispatch = yield* ThreadCommandExecutor.ThreadCommandExecutor; const orchestrator = yield* Orchestrator.OrchestratorV2; const sessions = yield* ProviderSessionManager.ProviderSessionManagerV2; @@ -941,23 +942,17 @@ const make = Effect.gen(function* () { Effect.flatMap((receipt) => Option.isSome(receipt) ? Effect.void - : Effect.serviceOption(ProviderRegistry.ProviderRegistry).pipe( - Effect.flatMap((registry) => - Option.isNone(registry) + : providerRegistry.getProviders.pipe( + Effect.flatMap((providers) => { + const detail = refuseUnservedModel(providers, selection); + return detail === undefined ? Effect.void - : registry.value.getProviders.pipe( - Effect.flatMap((providers) => { - const detail = refuseUnservedModel(providers, selection); - return detail === undefined - ? Effect.void - : new Orchestrator.OrchestratorCommandRejectedError({ - commandId: command.commandId, - commandType: command.type, - cause: detail, - }); - }), - ), - ), + : new Orchestrator.OrchestratorCommandRejectedError({ + commandId: command.commandId, + commandType: command.type, + cause: detail, + }); + }), ), ), ); @@ -1970,6 +1965,7 @@ export const layer: Layer.Layer< | ProviderSessionManager.ProviderSessionManagerV2 | ServerSettings.ServerSettingsService | CommandReceiptStore.CommandReceiptStoreV2 + | ProviderRegistry.ProviderRegistry > = Layer.effect(ThreadManagementService, make).pipe( Layer.provide(layerLegacyV1ThreadImporterNoop), Layer.provide(layerThreadWorktreeRestoreNoop), @@ -1985,4 +1981,5 @@ export const layerWithLegacyImporter: Layer.Layer< | ProviderSessionManager.ProviderSessionManagerV2 | ServerSettings.ServerSettingsService | CommandReceiptStore.CommandReceiptStoreV2 + | ProviderRegistry.ProviderRegistry > = Layer.effect(ThreadManagementService, make).pipe(Layer.provide(ThreadCommandExecutor.layer)); diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts index 3cb006f34d6b9..f078f8e666390 100644 --- a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts +++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts @@ -46,6 +46,7 @@ const layerIntakeTest = ServerConfig.layerTest(process.cwd(), { }).pipe( Layer.provideMerge(DocumentText.layer.pipe(Layer.provideMerge(NodeServices.layer))), Layer.provideMerge(ServerSettings.layerTest()), + Layer.provideMerge(ProviderRegistryMock.layer()), ); const layerFailingDispatchHandler = diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts index 3c09a2a24a90e..5f9cef414dec1 100644 --- a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts +++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts @@ -13,7 +13,6 @@ import * as ThreadLaunch from "./ThreadLaunchService.ts"; import * as ThreadManagement from "./ThreadManagementService.ts"; import * as ProviderRegistry from "../provider/ProviderRegistry.ts"; import { modelSelectionFromCommand, refuseUnservedModel } from "../provider/servedModel.ts"; -import * as Option from "effect/Option"; import { OrchestratorCommandRejectedError } from "./Orchestrator.ts"; // These failures precede commitCommand; generic dispatch errors can follow commits and remain ambiguous. @@ -100,16 +99,16 @@ export const dispatchCommand = Effect.fn("ThreadMessageIntake.dispatchCommand")( selection !== undefined && !(yield* threads.hasReceipt(command.commandId).pipe(Effect.orElseSucceed(() => false))) ) { - const registry = yield* Effect.serviceOption(ProviderRegistry.ProviderRegistry); - if (Option.isSome(registry)) { - const detail = refuseUnservedModel(yield* registry.value.getProviders, selection); - if (detail !== undefined) { - return yield* new OrchestratorCommandRejectedError({ - commandId: command.commandId, - commandType: command.type, - cause: detail, - }); - } + const detail = refuseUnservedModel( + yield* (yield* ProviderRegistry.ProviderRegistry).getProviders, + selection, + ); + if (detail !== undefined) { + return yield* new OrchestratorCommandRejectedError({ + commandId: command.commandId, + commandType: command.type, + cause: detail, + }); } } if (command.type === "runtime-request.respond" && command.attachmentsByQuestionId) { diff --git a/apps/server/src/orchestration-v2/ThreadStop.test.ts b/apps/server/src/orchestration-v2/ThreadStop.test.ts index fc52191d32b29..26665d01a39a5 100644 --- a/apps/server/src/orchestration-v2/ThreadStop.test.ts +++ b/apps/server/src/orchestration-v2/ThreadStop.test.ts @@ -45,6 +45,7 @@ import * as ThreadManagementService from "./ThreadManagementService.ts"; import * as ProviderReplayHarness from "./testkit/ProviderReplayHarness.ts"; import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace"; import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const instanceId = ProviderInstanceId.make("codex"); const modelSelection = { instanceId, model: "gpt-5.1-codex" }; @@ -57,6 +58,7 @@ const adapter = { } as ProviderAdapter.ProviderAdapterV2["Service"]; const layerDatabase = SqlitePersistence.layerMemory; const layerTest = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provideMerge( Layer.mergeAll( layerDatabase, @@ -2116,6 +2118,7 @@ it.effect.each([ }), ); const layerLive = ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(layerSessionsStartingFollowUpFirst), Layer.provideMerge( Layer.mergeAll( diff --git a/apps/server/src/orchestration-v2/ThreadTitleRegenerationService.test.ts b/apps/server/src/orchestration-v2/ThreadTitleRegenerationService.test.ts index cd4e4df9ff1a3..c73f72ea512fa 100644 --- a/apps/server/src/orchestration-v2/ThreadTitleRegenerationService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadTitleRegenerationService.test.ts @@ -36,6 +36,7 @@ import * as ThreadTitleRegeneration from "./ThreadTitleRegenerationService.ts"; import * as ProviderReplayHarness from "./testkit/ProviderReplayHarness.ts"; import { placeholderThreadTitle } from "./placeholderThreadTitle.ts"; import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const projectId = ProjectId.make("project:title-regeneration"); const modelSelection = { @@ -65,6 +66,7 @@ function makeHarness( ); const layerServerSettings = ServerSettings.layerTest({}); const layerThreadManagement = ThreadManagement.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide(layerOrchestrator), Layer.provide(layerServerSettings), Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))), diff --git a/apps/server/src/orchestration-v2/http.test.ts b/apps/server/src/orchestration-v2/http.test.ts index e65c05ea0c6f1..650fbc4f14e71 100644 --- a/apps/server/src/orchestration-v2/http.test.ts +++ b/apps/server/src/orchestration-v2/http.test.ts @@ -43,6 +43,7 @@ import * as CommandReceiptStore from "./CommandReceiptStore.ts"; import * as ThreadManagementService from "./ThreadManagementService.ts"; import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts"; import * as ProviderReplayHarness from "./testkit/ProviderReplayHarness.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; class TranscriptTestApi extends HttpApi.make("environment").add( EnvironmentHttpApi.groups.orchestration, @@ -129,6 +130,7 @@ const serveOrchestrationHttp = (allowed: () => boolean) => Layer.mergeAll( runtime, ThreadManagementService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide( Layer.mergeAll(runtime, CommandReceiptStore.layer, ServerSettings.layerTest({})), ), diff --git a/apps/server/src/orchestration-v2/runtimeLayer.test.ts b/apps/server/src/orchestration-v2/runtimeLayer.test.ts index a8fa42fe34afb..8a9ef0c8051b0 100644 --- a/apps/server/src/orchestration-v2/runtimeLayer.test.ts +++ b/apps/server/src/orchestration-v2/runtimeLayer.test.ts @@ -102,6 +102,7 @@ import * as ThreadLaunchService from "./ThreadLaunchService.ts"; import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts"; import * as DelegatedTaskQuestionReactor from "./DelegatedTaskQuestionReactor.ts"; import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const layerPlatformTest = Layer.merge( Layer.mergeAll(NodeServices.layer, NodeCrypto.layer), @@ -124,6 +125,7 @@ const layerVcsDriverRegistryTest = VcsDriverRegistry.layer.pipe( Layer.provide(VcsProcess.layer), Layer.provide(layerServerConfig), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); const layerCheckpointStoreTest = CheckpointStore.layer.pipe( @@ -361,6 +363,7 @@ const layerTest = Layer.mergeAll( Layer.provide(layerGitWorkflowTest), Layer.provide(layerProjectServiceTest), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); const layerLegacyImportTest = Layer.merge(RuntimeLayer.layer, layerProjectionReplayTest).pipe( @@ -374,9 +377,11 @@ const layerLegacyImportTest = Layer.merge(RuntimeLayer.layer, layerProjectionRep Layer.provide(layerGitWorkflowTest), Layer.provide(layerProjectServiceTest), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); const layerScheduledTasksTest = ScheduledTaskService.layer.pipe( + Layer.provide(ProviderRegistryMock.layer()), Layer.provide( Layer.mergeAll( ManagedPolicy.layerTest(), @@ -501,6 +506,7 @@ const layerProjectDeletionTest = Layer.mergeAll( Layer.provide(layerTestProviderInstanceRegistry), Layer.provide(layerGitWorkflowTest), Layer.provideMerge(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); it.layer(layerProjectDeletionTest)("project deletion during thread commands", (it) => { @@ -1381,6 +1387,7 @@ const layerSharedApplicationDataPlaneTest = Layer.mergeAll( Layer.provide(layerTestProviderInstanceRegistry), Layer.provide(layerGitWorkflowTest), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); it.layer(layerTest)("OrchestrationV2LayerLive", (it) => { @@ -3764,7 +3771,10 @@ it.layer(layerTest)("OrchestrationV2LayerLive lifecycle", (it) => { }); const standingShell = shellOf(yield* orchestrator.getShellSnapshot()); assert.deepEqual(standingShell.standing, persona); - assert.deepEqual((yield* orchestrator.getThreadProjection(threadId)).thread.standing, persona); + assert.deepEqual( + (yield* orchestrator.getThreadProjection(threadId)).thread.standing, + persona, + ); // Standing is identity, not activity: the thread keeps its place. assert.equal( DateTime.toEpochMillis(standingShell.updatedAt), @@ -12743,6 +12753,7 @@ const layerQueueResumeDisabledInstanceTest = Layer.mergeAll( Layer.provide(layerGitWorkflowTest), Layer.provide(layerProjectServiceTest), Layer.provide(layerPlatformTest), + Layer.provide(ProviderRegistryMock.layer()), ); it.layer(layerQueueResumeDisabledInstanceTest)( diff --git a/apps/server/src/provider/servedModel.ts b/apps/server/src/provider/servedModel.ts index c9d979ff53e80..2126e4691153d 100644 --- a/apps/server/src/provider/servedModel.ts +++ b/apps/server/src/provider/servedModel.ts @@ -7,7 +7,7 @@ import type { const LISTED_MODEL_LIMIT = 8; -type ListedModel = Pick; +type ListedModel = Pick; export function findServedModel>( models: ReadonlyArray, @@ -45,7 +45,12 @@ export function unservedModelMessage( model: string, models: ReadonlyArray, ): string | undefined { - if (models.length === 0 || findServedModel(models, model) !== undefined) return undefined; + if ( + models.length === 0 || + models.every((candidate) => candidate.isCustom) || + findServedModel(models, model) !== undefined + ) + return undefined; return `Model ${model} is not advertised by provider ${instanceId}. ${servedModelsHint(models, model)}`; } diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.interval.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.interval.test.ts index 86d6f26e06c44..7f962e348a79d 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.interval.test.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.interval.test.ts @@ -17,10 +17,12 @@ import * as SecretRequests from "../secrets/SecretRequests.ts"; import { ServerActivation } from "../serverActivation.ts"; import * as ScheduledTaskService from "./ScheduledTaskService.ts"; import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; afterEach(() => vi.unstubAllEnvs()); const dependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.schedule.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.schedule.test.ts index 92167ef83c5ca..2a3b1b52bf4a4 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.schedule.test.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.schedule.test.ts @@ -23,12 +23,14 @@ import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts"; import * as SqlitePersistence from "../persistence/Sqlite.ts"; import * as ScheduledTaskService from "./ScheduledTaskService.ts"; import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const decodeUpsertInput = Schema.decodeUnknownEffect(ScheduledTaskUpsertInput); it.effect("rejects a stale form save after deletion while preserving explicit-id creates", () => Effect.gen(function* () { const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), @@ -77,6 +79,7 @@ it.effect("preserves a due run when a save only pads the scheduled hour", () => yield* TestClock.setTime(DateTime.toEpochMillis(dueAt) - 1_000); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), @@ -132,6 +135,7 @@ it.effect("keeps the task list order when a toggle or edit rewrites updated_at", Effect.gen(function* () { yield* TestClock.setTime(Date.parse("2026-07-01T09:00:00.000Z")); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), @@ -196,6 +200,7 @@ it.effect("keeps one queued occurrence of a recurring task while its bound threa }>({ runs: [activeRun], messages: [] }); const runDueWork = yield* Ref.make>(Effect.void); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, ManagedPolicy.layerTest(), // Capture the poll pass so the test drives each due interval directly. @@ -338,6 +343,7 @@ it.effect( yield* TestClock.setTime(Date.parse("2026-07-01T09:00:00.000Z")); const launched = yield* Deferred.make(); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), @@ -403,6 +409,7 @@ it.effect("a fixed-time slot missed while the server was off shows on the task", yield* TestClock.setTime(DateTime.toEpochMillis(at(8))); const launches = yield* Ref.make(0); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), @@ -480,6 +487,7 @@ it.effect( const releaseSlow = yield* Deferred.make(); const lastProcessed = yield* Deferred.make(); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodeCrypto.layer, Scheduler.layer, ManagedPolicy.layerTest(), diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts index af5776fdb3596..a170f24d65a6d 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts @@ -204,6 +204,7 @@ it.effect( Layer.provideMerge( ScheduledTaskService.layer, Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -298,6 +299,7 @@ it.effect( Layer.provideMerge( ScheduledTaskService.layer, Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -363,6 +365,7 @@ it.effect("thread cleanup notifies subscribers and a finishing run cannot recrea const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({ @@ -437,6 +440,7 @@ it.effect.each([ const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({ @@ -523,6 +527,7 @@ it.effect("a bound run follows its thread when promotion moves it mid-send", () const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({ @@ -593,6 +598,7 @@ it.effect("a fresh-session task launches one thread, then starts each later run const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -687,6 +693,7 @@ it.effect("a refused dispatch records its refusal, and opaque causes stay generi const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({ @@ -734,6 +741,7 @@ it.effect("a first run whose thread was deleted before it bound removes the task const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -787,6 +795,7 @@ it.effect.each(["recreated under the same id", "moved to another project"] as co const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -848,6 +857,7 @@ it.effect("refuses saving an enabled task above the policy ceiling", () => const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest({ schemaVersion: 1, organization: "Example Corp", @@ -931,6 +941,7 @@ it.effect("checks a task's destination thread only when the destination changes" const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({ @@ -1009,6 +1020,7 @@ it.effect("a run interrupted right after it reserves the task does not block the const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer(), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({ launch: () => @@ -1098,6 +1110,7 @@ it.effect( const layer = ScheduledTaskService.layer.pipe( Layer.provide( Layer.mergeAll( + ProviderRegistryMock.layer([provider]), ManagedPolicy.layerTest(), Layer.mock(ThreadLaunchService.ThreadLaunchService)({}), Layer.mock(ThreadManagementService.ThreadManagementService)({}), @@ -1146,6 +1159,6 @@ it.effect( }); assert.equal(task.modelSelection.model, "claude-opus"); assert.equal(task.modelSelection.instanceId, "claudeAgent"); - }).pipe(Effect.provide(Layer.mergeAll(layer, ProviderRegistryMock.layer([provider])))); + }).pipe(Effect.provide(layer)); }).pipe(Effect.provide(SqlitePersistence.layerMemory)), ); diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.ts index ac742ee7d0dba..b49f53c2cf77d 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.ts @@ -485,6 +485,7 @@ export const layer = Layer.effect( const secretRequests = yield* SecretRequests.SecretRequests; const scheduler = yield* Scheduler.Scheduler; const readWebhookOrigin = yield* ScheduledTaskWebhookOrigin; + const providerRegistry = yield* ProviderRegistry.ProviderRegistry; const managedPolicy = yield* ManagedPolicy.ManagedPolicy; const webhookPolicyOrganization = ManagedPolicy.deniedBy(managedPolicy, "webhookTasks"); // Existing webhook tasks stay stored but report why they do not run. @@ -1429,14 +1430,11 @@ export const layer = Layer.effect( ScheduledTaskId.make( input.commandId ? `scheduled-task:${input.commandId}` : `scheduled-task:${uuid}`, ); - const registry = yield* Effect.serviceOption(ProviderRegistry.ProviderRegistry); - if (Option.isSome(registry)) { - const detail = refuseUnservedModel( - yield* registry.value.getProviders, - input.modelSelection, - ); - if (detail !== undefined) return yield* taskError(detail, { taskId: id }); - } + const detail = refuseUnservedModel( + yield* providerRegistry.getProviders, + input.modelSelection, + ); + if (detail !== undefined) return yield* taskError(detail, { taskId: id }); // Look up by the *resolved* id so idempotent creates (commandId replays) // keep their run history, and so real load failures propagate instead // of silently resetting an existing row. diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.webhook.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.webhook.test.ts index e06ed817ac4f4..0cf7837977b17 100644 --- a/apps/server/src/scheduledTasks/ScheduledTaskService.webhook.test.ts +++ b/apps/server/src/scheduledTasks/ScheduledTaskService.webhook.test.ts @@ -32,6 +32,7 @@ import * as SqlitePersistence from "../persistence/Sqlite.ts"; import * as Scheduler from "../scheduling/Scheduler.ts"; import * as ScheduledTaskService from "./ScheduledTaskService.ts"; import { renderWebhookPrompt } from "./webhookTemplate.ts"; +import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts"; const decodeUpsertInput = Schema.decodeUnknownEffect(ScheduledTaskUpsertInput); @@ -182,6 +183,7 @@ const withService = ( const launches = yield* Queue.unbounded(); const secretsByRef = new Map(); const layerDependencies = Layer.mergeAll( + ProviderRegistryMock.layer(), NodePlatformCrypto.layerDigest, NodePlatformCrypto.layerMac, options.frameGate === undefined && options.onFrame === undefined diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts index 3a0ee0f6cb77d..d4e09cb570379 100644 --- a/apps/server/src/ws.ts +++ b/apps/server/src/ws.ts @@ -1445,6 +1445,7 @@ export const layerWsRpc = ( | ServerConfig.ServerConfig | ServerSettings.ServerSettingsService | DocumentText.DocumentText + | ProviderRegistry.ProviderRegistry >(); const applicationEvents = yield* OrchestrationEventStore.OrchestrationEventStore; const projectStore = yield* ProjectStore.ProjectStoreV2;