Fix shared model provider inference for first turns

Author: zortos293

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts

@@ -110,7 +110,9 @@ describe("ProviderCommandReactor", () => {
         typeof input === "object" &&
         input !== null &&
         "provider" in input &&
-        (input.provider === "codex" || input.provider === "claudeAgent")
+        (input.provider === "codex" ||
+          input.provider === "copilot" ||
+          input.provider === "claudeAgent")
           ? input.provider
           : "codex";
       const resumeCursor =
@@ -552,6 +554,46 @@ describe("ProviderCommandReactor", () => {
     });
   });
 
+  it("binds a first turn to the requested provider when the model slug is shared", async () => {
+    const harness = await createHarness({ threadModel: "gpt-5.4" });
+    const now = new Date().toISOString();
+
+    await Effect.runPromise(
+      harness.engine.dispatch({
+        type: "thread.turn.start",
+        commandId: CommandId.makeUnsafe("cmd-turn-start-shared-model-provider"),
+        threadId: ThreadId.makeUnsafe("thread-1"),
+        message: {
+          messageId: asMessageId("user-message-shared-model-provider"),
+          role: "user",
+          text: "hello copilot",
+          attachments: [],
+        },
+        provider: "copilot",
+        model: "gpt-5.4",
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "approval-required",
+        createdAt: now,
+      }),
+    );
+
+    await waitFor(() => harness.startSession.mock.calls.length === 1);
+    await waitFor(() => harness.sendTurn.mock.calls.length === 1);
+
+    expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
+      provider: "copilot",
+      model: "gpt-5.4",
+    });
+    expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
+      threadId: ThreadId.makeUnsafe("thread-1"),
+      model: "gpt-5.4",
+    });
+
+    const readModel = await Effect.runPromise(harness.engine.getReadModel());
+    const thread = readModel.threads.find((entry) => entry.id === ThreadId.makeUnsafe("thread-1"));
+    expect(thread?.session?.providerName).toBe("copilot");
+  });
+
   it("rejects a turn when the requested model belongs to a different provider", async () => {
     const harness = await createHarness();
     const now = new Date().toISOString();

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts

@@ -233,7 +233,8 @@ const make = Effect.gen(function* () {
     )
       ? thread.session.providerName
       : undefined;
-    const threadProvider: ProviderKind = currentProvider ?? inferProviderForModel(thread.model);
+    const threadProvider: ProviderKind =
+      currentProvider ?? inferProviderForModel(thread.model, options?.provider ?? "codex");
     if (options?.provider !== undefined && options.provider !== threadProvider) {
       return yield* new ProviderAdapterRequestError({
         provider: threadProvider,

packages/shared/src/model.test.ts

@@ -207,6 +207,10 @@ describe("inferProviderForModel", () => {
     expect(inferProviderForModel("sonnet")).toBe("claudeAgent");
   });
 
+  it("prefers the fallback provider for shared model slugs", () => {
+    expect(inferProviderForModel("gpt-5.4", "copilot")).toBe("copilot");
+  });
+
   it("falls back when the model is unknown", () => {
     expect(inferProviderForModel("custom/internal-model")).toBe("codex");
     expect(inferProviderForModel("custom/internal-model", "claudeAgent")).toBe("claudeAgent");

packages/shared/src/model.ts

@@ -141,6 +141,11 @@ export function inferProviderForModel(
   model: string | null | undefined,
   fallback: ProviderKind = "codex",
 ): ProviderKind {
+  const normalizedFallback = normalizeModelSlug(model, fallback);
+  if (normalizedFallback && MODEL_SLUG_SET_BY_PROVIDER[fallback].has(normalizedFallback)) {
+    return fallback;
+  }
+
   const normalizedClaude = normalizeModelSlug(model, "claudeAgent");
   if (normalizedClaude && MODEL_SLUG_SET_BY_PROVIDER.claudeAgent.has(normalizedClaude)) {
     return "claudeAgent";
@@ -151,7 +156,14 @@ export function inferProviderForModel(
     return "codex";
   }
 
-  return typeof model === "string" && model.trim().startsWith("claude-") ? "claudeAgent" : fallback;
+  const trimmed = typeof model === "string" ? model.trim() : "";
+  if (trimmed.startsWith("claude-")) {
+    return "claudeAgent";
+  }
+  if (trimmed.startsWith("gpt-")) {
+    return "codex";
+  }
+  return fallback;
 }
 
 export function getReasoningEffortOptions(provider: "codex"): ReadonlyArray<CodexReasoningEffort>;