lael-labs/t3code

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts+44−30

     expect(harness.startSession.mock.calls[0]?.[0]).toEqual(ThreadId.makeUnsafe("thread-1"));
     expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
       cwd: "/tmp/provider-project",
-      model: "gpt-5-codex",
+      modelSelection: {
+        provider: "codex",
+        model: "gpt-5-codex",
+      },
       runtimeMode: "approval-required",
     });
     await waitFor(() => harness.startSession.mock.calls.length === 1);
     await waitFor(() => harness.sendTurn.mock.calls.length === 1);
     expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
-      model: "gpt-5.3-codex",
+      modelSelection: {
-      modelOptions: {
+        provider: "codex",
-        codex: {
+        model: "gpt-5.3-codex",
+        options: {
           reasoningEffort: "high",
           fastMode: true,
         },
     });
     expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
       threadId: ThreadId.makeUnsafe("thread-1"),
-      model: "gpt-5.3-codex",
+      modelSelection: {
-      modelOptions: {
+        provider: "codex",
-        codex: {
+        model: "gpt-5.3-codex",
+        options: {
           reasoningEffort: "high",
           fastMode: true,
         },
     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: "claudeAgent",
+      modelSelection: {
-      model: "claude-sonnet-4-6",
+        provider: "claudeAgent",
-      modelOptions: {
+        model: "claude-sonnet-4-6",
-        claudeAgent: {
+        options: {
           effort: "max",
         },
       },
     });
     expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
       threadId: ThreadId.makeUnsafe("thread-1"),
-      model: "claude-sonnet-4-6",
+      modelSelection: {
-      modelOptions: {
+        provider: "claudeAgent",
-        claudeAgent: {
+        model: "claude-sonnet-4-6",
+        options: {
           effort: "max",
         },
       },
     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: "claudeAgent",
+      modelSelection: {
-      model: "claude-opus-4-6",
+        provider: "claudeAgent",
-      modelOptions: {
+        model: "claude-opus-4-6",
-        claudeAgent: {
+        options: {
           fastMode: true,
         },
       },
     });
     expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
       threadId: ThreadId.makeUnsafe("thread-1"),
-      model: "claude-opus-4-6",
+      modelSelection: {
-      modelOptions: {
+        provider: "claudeAgent",
-        claudeAgent: {
+        model: "claude-opus-4-6",
+        options: {
           fastMode: true,
         },
       },
     await waitFor(() => harness.sendTurn.mock.calls.length === 1);
     expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
-      provider: "codex",
+      modelSelection: {
-      model: "claude-sonnet-4-6",
+        provider: "codex",
+        model: "claude-sonnet-4-6",
+      },
     });
     expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
       threadId: ThreadId.makeUnsafe("thread-1"),
-      model: "claude-sonnet-4-6",
+      modelSelection: {
+        provider: "codex",
+        model: "claude-sonnet-4-6",
+      },
     });
   });
     await waitFor(() => harness.startSession.mock.calls.length === 2);
     await waitFor(() => harness.sendTurn.mock.calls.length === 2);
     expect(harness.startSession.mock.calls[1]?.[1]).toMatchObject({
-      provider: "claudeAgent",
       resumeCursor: { opaque: "resume-1" },
-      modelOptions: {
+      modelSelection: {
-        claudeAgent: {
+        provider: "claudeAgent",
+        model: "claude-sonnet-4-6",
+        options: {
           effort: "max",
         },
       },
     await waitFor(() => harness.startSession.mock.calls.length === 1);
     expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
-      provider: "claudeAgent",
+      modelSelection: {
-      model: "claude-opus-4-6",
+        provider: "claudeAgent",
+        model: "claude-opus-4-6",
+      },
       runtimeMode: "approval-required",
     });
-    expect(harness.startSession.mock.calls[0]?.[1]).not.toHaveProperty("modelOptions");
   });
   it("rejects provider changes after a thread is already bound to a session provider", async () => {

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+24−32

   EventId,
   type ModelSelection,
   type OrchestrationEvent,
-  type ProviderModelOptions,
   ProviderKind,
   type ProviderStartOptions,
   type OrchestrationSession,
 } from "@t3tools/contracts";
 import { Cache, Cause, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
 import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";
-import { toProviderModelOptions } from "@t3tools/shared/model";
 import { resolveThreadWorkspaceCwd } from "../../checkpointing/Utils.ts";
 import { GitCore } from "../../git/Services/GitCore.ts";
 const WORKTREE_BRANCH_PREFIX = "t3code";
 const TEMP_WORKTREE_BRANCH_PATTERN = new RegExp(`^${WORKTREE_BRANCH_PREFIX}\\/[0-9a-f]{8}$`);
-const sameModelOptions = (
+const sameModelSelectionOptions = (
-  left: ProviderModelOptions | undefined,
+  left: ModelSelection | undefined,
-  right: ProviderModelOptions | undefined,
+  right: ModelSelection | undefined,
 ): boolean => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
 function isUnknownPendingApprovalRequestError(cause: Cause.Cause<ProviderServiceError>): boolean {
     );
   const threadProviderOptions = new Map<string, ProviderStartOptions>();
-  const threadModelOptions = new Map<string, ProviderModelOptions>();
+  const threadModelSelections = new Map<string, ModelSelection>();
   const appendProviderFailureActivity = (input: {
     readonly threadId: ThreadId;
     createdAt: string,
     options?: {
       readonly modelSelection?: ModelSelection;
-      readonly modelOptions?: ProviderModelOptions;
       readonly providerOptions?: ProviderStartOptions;
     },
   ) {
     }
     const preferredProvider: ProviderKind = currentProvider ?? threadProvider;
     const desiredModelSelection = requestedModelSelection ?? thread.modelSelection;
-    const desiredModel = desiredModelSelection.model;
-    const desiredModelOptions =
-      options?.modelOptions ?? toProviderModelOptions(desiredModelSelection);
     const effectiveCwd = resolveThreadWorkspaceCwd({
       thread,
       projects: readModel.projects,
         threadId,
         ...(preferredProvider ? { provider: preferredProvider } : {}),
         ...(effectiveCwd ? { cwd: effectiveCwd } : {}),
-        ...(desiredModel ? { model: desiredModel } : {}),
+        modelSelection: desiredModelSelection,
-        ...(desiredModelOptions !== undefined ? { modelOptions: desiredModelOptions } : {}),
         ...(options?.providerOptions !== undefined
           ? { providerOptions: options.providerOptions }
           : {}),
         requestedModelSelection !== undefined &&
         requestedModelSelection.model !== activeSession?.model;
       const shouldRestartForModelChange = modelChanged && sessionModelSwitch === "restart-session";
-      const previousModelOptions = threadModelOptions.get(threadId);
+      const previousModelSelection = threadModelSelections.get(threadId);
-      const shouldRestartForModelOptionsChange =
+      const shouldRestartForModelSelectionChange =
         currentProvider === "claudeAgent" &&
-        options?.modelOptions !== undefined &&
+        requestedModelSelection !== undefined &&
-        !sameModelOptions(previousModelOptions, options.modelOptions);
+        !sameModelSelectionOptions(previousModelSelection, requestedModelSelection);
       if (
         !runtimeModeChanged &&
         !providerChanged &&
         !shouldRestartForModelChange &&
-        !shouldRestartForModelOptionsChange
+        !shouldRestartForModelSelectionChange
       ) {
         return existingSessionThreadId;
       }
         providerChanged,
         modelChanged,
         shouldRestartForModelChange,
-        shouldRestartForModelOptionsChange,
+        shouldRestartForModelSelectionChange,
         hasResumeCursor: resumeCursor !== undefined,
       });
       const restartedSession = yield* startProviderSession(
     readonly messageText: string;
     readonly attachments?: ReadonlyArray<ChatAttachment>;
     readonly modelSelection?: ModelSelection;
-    readonly modelOptions?: ProviderModelOptions;
     readonly providerOptions?: ProviderStartOptions;
     readonly interactionMode?: "default" | "plan";
     readonly createdAt: string;
     }
     yield* ensureSessionForThread(input.threadId, input.createdAt, {
       ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
-      ...(input.modelOptions !== undefined ? { modelOptions: input.modelOptions } : {}),
       ...(input.providerOptions !== undefined ? { providerOptions: input.providerOptions } : {}),
     });
     if (input.providerOptions !== undefined) {
       threadProviderOptions.set(input.threadId, input.providerOptions);
     }
-    if (input.modelOptions !== undefined) {
+    if (input.modelSelection !== undefined) {
-      threadModelOptions.set(input.threadId, input.modelOptions);
+      threadModelSelections.set(input.threadId, input.modelSelection);
     }
     const normalizedInput = toNonEmptyProviderInput(input.messageText);
     const normalizedAttachments = input.attachments ?? [];
         ? "in-session"
         : (yield* providerService.getCapabilities(activeSession.provider)).sessionModelSwitch;
     const modelForTurn =
-      sessionModelSwitch === "unsupported" ? activeSession?.model : input.modelSelection?.model;
+      sessionModelSwitch === "unsupported"
+        ? input.modelSelection
+          ? {
+              ...input.modelSelection,
+              model: activeSession?.model ?? input.modelSelection.model,
+            }
+          : undefined
+        : input.modelSelection;
     yield* providerService.sendTurn({
       threadId: input.threadId,
       ...(normalizedInput ? { input: normalizedInput } : {}),
       ...(normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {}),
-      ...(modelForTurn !== undefined ? { model: modelForTurn } : {}),
+      ...(modelForTurn !== undefined ? { modelSelection: modelForTurn } : {}),
-      ...(input.modelOptions !== undefined ? { modelOptions: input.modelOptions } : {}),
       ...(input.interactionMode !== undefined ? { interactionMode: input.interactionMode } : {}),
     });
   });
       ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),
     }).pipe(Effect.forkScoped);
-    const requestedModelOptions = event.payload.modelSelection
-      ? toProviderModelOptions(event.payload.modelSelection)
-      : undefined;
     yield* sendTurnForThread({
       threadId: event.payload.threadId,
       messageText: message.text,
       ...(event.payload.modelSelection !== undefined
         ? { modelSelection: event.payload.modelSelection }
         : {}),
-      ...(requestedModelOptions !== undefined ? { modelOptions: requestedModelOptions } : {}),
       ...(event.payload.providerOptions !== undefined
         ? { providerOptions: event.payload.providerOptions }
         : {}),
             return;
           }
           const cachedProviderOptions = threadProviderOptions.get(event.payload.threadId);
-          const cachedModelOptions = threadModelOptions.get(event.payload.threadId);
+          const cachedModelSelection = threadModelSelections.get(event.payload.threadId);
           yield* ensureSessionForThread(event.payload.threadId, event.occurredAt, {
             ...(cachedProviderOptions !== undefined
               ? { providerOptions: cachedProviderOptions }
               : {}),
-            ...(cachedModelOptions !== undefined ? { modelOptions: cachedModelOptions } : {}),
+            ...(cachedModelSelection !== undefined ? { modelSelection: cachedModelSelection } : {}),
           });
           return;
         }

apps/server/src/provider/Layers/ClaudeAdapter.test.ts+52−37

       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-opus-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-opus-4-6",
-          claudeAgent: {
+          options: {
             effort: "max",
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-sonnet-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-sonnet-4-6",
-          claudeAgent: {
+          options: {
             effort: "max",
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-haiku-4-5",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-haiku-4-5",
-          claudeAgent: {
+          options: {
             effort: "high",
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-haiku-4-5",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-haiku-4-5",
-          claudeAgent: {
+          options: {
             thinking: false,
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-sonnet-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-sonnet-4-6",
-          claudeAgent: {
+          options: {
             thinking: false,
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-opus-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-opus-4-6",
-          claudeAgent: {
+          options: {
             fastMode: true,
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-sonnet-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-sonnet-4-6",
-          claudeAgent: {
+          options: {
             fastMode: true,
           },
         },
+        runtimeMode: "full-access",
       });
       const createInput = harness.getLastCreateQueryInput();
       const session = yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-sonnet-4-6",
+        modelSelection: {
-        runtimeMode: "full-access",
+          provider: "claudeAgent",
-        modelOptions: {
+          model: "claude-sonnet-4-6",
-          claudeAgent: {
+          options: {
             effort: "ultrathink",
           },
         },
+        runtimeMode: "full-access",
       });
       yield* adapter.sendTurn({
         threadId: session.threadId,
         input: "Investigate the edge cases",
         attachments: [],
-        model: "claude-sonnet-4-6",
+        modelSelection: {
-        modelOptions: {
+          provider: "claudeAgent",
-          claudeAgent: {
+          model: "claude-sonnet-4-6",
+          options: {
             effort: "ultrathink",
           },
         },
       const session = yield* adapter.startSession({
         threadId: THREAD_ID,
         provider: "claudeAgent",
-        model: "claude-sonnet-4-5",
+        modelSelection: {
+          provider: "claudeAgent",
+          model: "claude-sonnet-4-5",
+        },
         runtimeMode: "full-access",
       });
       yield* adapter.sendTurn({
         threadId: session.threadId,
         input: "hello",
-        model: "claude-opus-4-6",
+        modelSelection: {
+          provider: "claudeAgent",
+          model: "claude-opus-4-6",
+        },
         attachments: [],
       });

apps/server/src/provider/Layers/ClaudeAdapter.ts+29−15

 function buildPromptText(input: ProviderSendTurnInput): string {
   const requestedEffort = resolveReasoningEffortForProvider(
     "claudeAgent",
-    input.modelOptions?.claudeAgent?.effort ?? null,
+    input.modelSelection?.provider === "claudeAgent" ? input.modelSelection.options?.effort : null,
+  );
+  const supportedEffortOptions = getReasoningEffortOptions(
+    "claudeAgent",
+    input.modelSelection?.provider === "claudeAgent" ? input.modelSelection.model : undefined,
   );
-  const supportedEffortOptions = getReasoningEffortOptions("claudeAgent", input.model);
   const promptEffort =
-    requestedEffort === "ultrathink" && supportsClaudeUltrathinkKeyword(input.model)
+    requestedEffort === "ultrathink" &&
+    supportsClaudeUltrathinkKeyword(
+      input.modelSelection?.provider === "claudeAgent" ? input.modelSelection.model : undefined,
+    )
       ? "ultrathink"
       : requestedEffort && supportedEffortOptions.includes(requestedEffort)
         ? requestedEffort
           );
         const providerOptions = input.providerOptions?.claudeAgent;
+        const modelSelection =
+          input.modelSelection?.provider === "claudeAgent" ? input.modelSelection : undefined;
         const requestedEffort = resolveReasoningEffortForProvider(
           "claudeAgent",
-          input.modelOptions?.claudeAgent?.effort ?? null,
+          modelSelection?.options?.effort ?? null,
+        );
+        const supportedEffortOptions = getReasoningEffortOptions(
+          "claudeAgent",
+          modelSelection?.model,
         );
-        const supportedEffortOptions = getReasoningEffortOptions("claudeAgent", input.model);
         const effort =
           requestedEffort && supportedEffortOptions.includes(requestedEffort)
             ? requestedEffort
             : null;
         const fastMode =
-          input.modelOptions?.claudeAgent?.fastMode === true && supportsClaudeFastMode(input.model);
+          modelSelection?.options?.fastMode === true &&
+          supportsClaudeFastMode(modelSelection?.model);
         const thinking =
-          typeof input.modelOptions?.claudeAgent?.thinking === "boolean" &&
+          typeof modelSelection?.options?.thinking === "boolean" &&
-          supportsClaudeThinkingToggle(input.model)
+          supportsClaudeThinkingToggle(modelSelection?.model)
-            ? input.modelOptions.claudeAgent.thinking
+            ? modelSelection.options.thinking
             : undefined;
         const effectiveEffort = getEffectiveClaudeCodeEffort(effort);
         const permissionMode =
         const queryOptions: ClaudeQueryOptions = {
           ...(input.cwd ? { cwd: input.cwd } : {}),
-          ...(input.model ? { model: input.model } : {}),
+          ...(modelSelection?.model ? { model: modelSelection.model } : {}),
           pathToClaudeCodeExecutable: providerOptions?.binaryPath ?? "claude",
           settingSources: [...CLAUDE_SETTING_SOURCES],
           ...(effectiveEffort ? { effort: effectiveEffort } : {}),
           status: "ready",
           runtimeMode: input.runtimeMode,
           ...(input.cwd ? { cwd: input.cwd } : {}),
-          ...(input.model ? { model: input.model } : {}),
+          ...(modelSelection?.model ? { model: modelSelection.model } : {}),
           ...(threadId ? { threadId } : {}),
           resumeCursor: {
             ...(threadId ? { threadId } : {}),
           threadId,
           payload: {
             config: {
-              ...(input.model ? { model: input.model } : {}),
+              ...(modelSelection?.model ? { model: modelSelection.model } : {}),
               ...(input.cwd ? { cwd: input.cwd } : {}),
               ...(effectiveEffort ? { effort: effectiveEffort } : {}),
               ...(permissionMode ? { permissionMode } : {}),
     const sendTurn: ClaudeAdapterShape["sendTurn"] = (input) =>
       Effect.gen(function* () {
         const context = yield* requireSession(input.threadId);
+        const modelSelection =
+          input.modelSelection?.provider === "claudeAgent" ? input.modelSelection : undefined;
         if (context.turnState) {
           // Auto-close a stale synthetic turn (from background agent responses
           yield* completeTurn(context, "completed");
         }
-        if (input.model) {
+        if (modelSelection?.model) {
           yield* Effect.tryPromise({
-            try: () => context.query.setModel(input.model),
+            try: () => context.query.setModel(modelSelection.model),
             catch: (cause) => toRequestError(input.threadId, "turn/setModel", cause),
           });
         }
           createdAt: turnStartedStamp.createdAt,
           threadId: context.session.threadId,
           turnId,
-          payload: input.model ? { model: input.model } : {},
+          payload: modelSelection?.model ? { model: modelSelection.model } : {},
           providerRefs: {},
         });

apps/server/src/provider/Layers/CodexAdapter.test.ts+8−6

       yield* adapter.startSession({
         provider: "codex",
         threadId: asThreadId("thread-1"),
-        model: "gpt-5.3-codex",
+        modelSelection: {
-        modelOptions: {
+          provider: "codex",
-          codex: {
+          model: "gpt-5.3-codex",
+          options: {
             fastMode: true,
           },
         },
         adapter.sendTurn({
           threadId: asThreadId("sess-missing"),
           input: "hello",
-          model: "gpt-5.3-codex",
+          modelSelection: {
-          modelOptions: {
+            provider: "codex",
-            codex: {
+            model: "gpt-5.3-codex",
+            options: {
               reasoningEffort: "high",
               fastMode: true,
             },

apps/server/src/provider/Layers/CodexAdapter.ts+16−6

         ...(input.resumeCursor !== undefined ? { resumeCursor: input.resumeCursor } : {}),
         ...(input.providerOptions !== undefined ? { providerOptions: input.providerOptions } : {}),
         runtimeMode: input.runtimeMode,
-        ...(input.model !== undefined ? { model: input.model } : {}),
+        ...(input.modelSelection?.provider === "codex"
-        ...(input.modelOptions?.codex?.fastMode ? { serviceTier: "fast" } : {}),
+          ? { model: input.modelSelection.model }
+          : {}),
+        ...(input.modelSelection?.provider === "codex" && input.modelSelection.options?.fastMode
+          ? { serviceTier: "fast" }
+          : {}),
       };
       return Effect.tryPromise({
             const managerInput = {
               threadId: input.threadId,
               ...(input.input !== undefined ? { input: input.input } : {}),
-              ...(input.model !== undefined ? { model: input.model } : {}),
+              ...(input.modelSelection?.provider === "codex"
-              ...(input.modelOptions?.codex?.reasoningEffort !== undefined
+                ? { model: input.modelSelection.model }
-                ? { effort: input.modelOptions.codex.reasoningEffort }
+                : {}),
+              ...(input.modelSelection?.provider === "codex" &&
+              input.modelSelection.options?.reasoningEffort !== undefined
+                ? { effort: input.modelSelection.options.reasoningEffort }
+                : {}),
+              ...(input.modelSelection?.provider === "codex" &&
+              input.modelSelection.options?.fastMode
+                ? { serviceTier: "fast" }
                 : {}),
-              ...(input.modelOptions?.codex?.fastMode ? { serviceTier: "fast" } : {}),
               ...(input.interactionMode !== undefined
                 ? { interactionMode: input.interactionMode }
                 : {}),

apps/server/src/provider/Layers/ProviderService.test.ts+9−5

         provider: "claudeAgent",
         threadId: asThreadId("thread-claude-send-turn"),
         cwd: "/tmp/project-claude-send-turn",
-        modelOptions: {
+        modelSelection: {
-          claudeAgent: {
+          provider: "claudeAgent",
+          model: "claude-opus-4-6",
+          options: {
             effort: "max",
           },
         },
         const startPayload = resumedStartInput as {
           provider?: string;
           cwd?: string;
-          modelOptions?: unknown;
+          modelSelection?: unknown;
           resumeCursor?: unknown;
           threadId?: string;
         };
         assert.equal(startPayload.provider, "claudeAgent");
         assert.equal(startPayload.cwd, "/tmp/project-claude-send-turn");
-        assert.deepEqual(startPayload.modelOptions, {
+        assert.deepEqual(startPayload.modelSelection, {
-          claudeAgent: {
+          provider: "claudeAgent",
+          model: "claude-opus-4-6",
+          options: {
             effort: "max",
           },
         });

apps/server/src/provider/Layers/ProviderService.ts+16−13

  * @module ProviderServiceLive
  */
 import {
+  ModelSelection,
   NonNegativeInt,
   ThreadId,
   ProviderInterruptTurnInput,
 function toRuntimePayloadFromSession(
   session: ProviderSession,
   extra?: {
-    readonly modelOptions?: unknown;
+    readonly modelSelection?: unknown;
     readonly providerOptions?: unknown;
     readonly lastRuntimeEvent?: string;
     readonly lastRuntimeEventAt?: string;
     model: session.model ?? null,
     activeTurnId: session.activeTurnId ?? null,
     lastError: session.lastError ?? null,
-    ...(extra?.modelOptions !== undefined ? { modelOptions: extra.modelOptions } : {}),
+    ...(extra?.modelSelection !== undefined ? { modelSelection: extra.modelSelection } : {}),
     ...(extra?.providerOptions !== undefined ? { providerOptions: extra.providerOptions } : {}),
     ...(extra?.lastRuntimeEvent !== undefined ? { lastRuntimeEvent: extra.lastRuntimeEvent } : {}),
     ...(extra?.lastRuntimeEventAt !== undefined
   };
 }
-function readPersistedModelOptions(
+function readPersistedModelSelection(
   runtimePayload: ProviderRuntimeBinding["runtimePayload"],
-): Record<string, unknown> | undefined {
+): ModelSelection | undefined {
   if (!runtimePayload || typeof runtimePayload !== "object" || Array.isArray(runtimePayload)) {
     return undefined;
   }
-  const raw = "modelOptions" in runtimePayload ? runtimePayload.modelOptions : undefined;
+  const raw = "modelSelection" in runtimePayload ? runtimePayload.modelSelection : undefined;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  return Schema.is(ModelSelection)(raw) ? raw : undefined;
-  return raw as Record<string, unknown>;
 }
 function readPersistedProviderOptions(
       session: ProviderSession,
       threadId: ThreadId,
       extra?: {
-        readonly modelOptions?: unknown;
+        readonly modelSelection?: unknown;
         readonly providerOptions?: unknown;
         readonly lastRuntimeEvent?: string;
         readonly lastRuntimeEventAt?: string;
         }
         const persistedCwd = readPersistedCwd(input.binding.runtimePayload);
-        const persistedModelOptions = readPersistedModelOptions(input.binding.runtimePayload);
+        const persistedModelSelection = readPersistedModelSelection(input.binding.runtimePayload);
         const persistedProviderOptions = readPersistedProviderOptions(input.binding.runtimePayload);
         const resumed = yield* adapter.startSession({
           threadId: input.binding.threadId,
           provider: input.binding.provider,
           ...(persistedCwd ? { cwd: persistedCwd } : {}),
-          ...(persistedModelOptions ? { modelOptions: persistedModelOptions } : {}),
+          ...(persistedModelSelection ? { modelSelection: persistedModelSelection } : {}),
           ...(persistedProviderOptions ? { providerOptions: persistedProviderOptions } : {}),
           ...(hasResumeCursor ? { resumeCursor: input.binding.resumeCursor } : {}),
           runtimeMode: input.binding.runtimeMode ?? "full-access",
         }
         yield* upsertSessionBinding(session, threadId, {
-          modelOptions: input.modelOptions,
+          modelSelection: input.modelSelection,
           providerOptions: input.providerOptions,
         });
         yield* analytics.record("provider.session.started", {
           runtimeMode: input.runtimeMode,
           hasResumeCursor: session.resumeCursor !== undefined,
           hasCwd: typeof input.cwd === "string" && input.cwd.trim().length > 0,
-          hasModel: typeof input.model === "string" && input.model.trim().length > 0,
+          hasModel:
+            typeof input.modelSelection?.model === "string" &&
+            input.modelSelection.model.trim().length > 0,
         });
         return session;
           status: "running",
           ...(turn.resumeCursor !== undefined ? { resumeCursor: turn.resumeCursor } : {}),
           runtimePayload: {
+            ...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
             activeTurnId: turn.turnId,
             lastRuntimeEvent: "provider.sendTurn",
             lastRuntimeEventAt: new Date().toISOString(),
         });
         yield* analytics.record("provider.turn.sent", {
           provider: routed.adapter.provider,
-          model: input.model,
+          model: input.modelSelection?.model,
           interactionMode: input.interactionMode,
           attachmentCount: input.attachments.length,
           hasInput: typeof input.input === "string" && input.input.trim().length > 0,

apps/web/src/components/ChatView.tsx+3−19

   type ProjectScript,
   type ModelSlug,
   type ProviderKind,
-  type ProviderModelOptions,
   type ProjectEntry,
   type ProjectId,
   type ProviderApprovalDecision,
   getDefaultModel,
   normalizeModelSlug,
   resolveModelSlugForProvider,
-  toProviderModelOptions,
 } from "@t3tools/shared/model";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
   }
   return params.text;
 }
-function extractModelSelectionOptions(
-  provider: ProviderKind,
-  modelOptions: ProviderModelOptions | undefined,
-): ModelSelection["options"] | undefined {
-  return provider === "codex" ? modelOptions?.codex : modelOptions?.claudeAgent;
-}
 const COMPOSER_PATH_QUERY_DEBOUNCE_MS = 120;
 const SCRIPT_TERMINAL_COLS = 120;
 const SCRIPT_TERMINAL_ROWS = 30;
     customModelsByProvider,
     selectedProvider,
   ]);
-  const draftModelOptions = toProviderModelOptions(composerDraft.modelSelection);
   const composerProviderState = useMemo(
     () =>
       getComposerProviderState({
         provider: selectedProvider,
         model: selectedModel,
         prompt,
-        modelOptions: draftModelOptions,
+        modelOptions: composerDraft.modelSelection?.options,
       }),
-    [draftModelOptions, prompt, selectedModel, selectedProvider],
+    [composerDraft.modelSelection?.options, prompt, selectedModel, selectedProvider],
   );
   const selectedPromptEffort = composerProviderState.promptEffort;
   const selectedModelOptionsForDispatch = composerProviderState.modelOptionsForDispatch;
     () => ({
       provider: selectedProvider,
       model: selectedModel,
-      ...(extractModelSelectionOptions(selectedProvider, selectedModelOptionsForDispatch)
+      ...(selectedModelOptionsForDispatch ? { options: selectedModelOptionsForDispatch } : {}),
-        ? {
-            options: extractModelSelectionOptions(
-              selectedProvider,
-              selectedModelOptionsForDispatch,
-            ),
-          }
-        : {}),
     }),
     [selectedModel, selectedModelOptionsForDispatch, selectedProvider],
   );

apps/web/src/components/chat/composerProviderRegistry.test.tsx+9−61

@@ -23,10 +23,8 @@ describe("getComposerProviderState", () => { · 22 unmodified lines
23	model: "gpt-5.4",	23	model: "gpt-5.4",
24	prompt: "",	24	prompt: "",
25	modelOptions: {	25	modelOptions: {
26	codex: {	26	reasoningEffort: "low",
27	reasoningEffort: "low",	27	fastMode: true,
28	fastMode: true,
29	},
30	},	28	},
31	});	29	});
32		30
@@ -34,10 +32,8 @@ describe("getComposerProviderState", () => { · 1 unmodified line
34	provider: "codex",	32	provider: "codex",
35	promptEffort: "low",	33	promptEffort: "low",
36	modelOptionsForDispatch: {	34	modelOptionsForDispatch: {
37	codex: {	35	reasoningEffort: "low",
38	reasoningEffort: "low",	36	fastMode: true,
39	fastMode: true,
40	},
41	},	37	},
42	});	38	});
43	});	39	});
@@ -63,9 +59,7 @@ describe("getComposerProviderState", () => { · 19 unmodified lines
63	model: "claude-sonnet-4-6",	59	model: "claude-sonnet-4-6",
64	prompt: "Ultrathink:\nInvestigate this failure",	60	prompt: "Ultrathink:\nInvestigate this failure",
65	modelOptions: {	61	modelOptions: {
66	claudeAgent: {	62	effort: "medium",
67	effort: "medium",
68	},
69	},	63	},
70	});	64	});
71		65
@@ -73,9 +67,7 @@ describe("getComposerProviderState", () => { · 1 unmodified line
73	provider: "claudeAgent",	67	provider: "claudeAgent",
74	promptEffort: "medium",	68	promptEffort: "medium",
75	modelOptionsForDispatch: {	69	modelOptionsForDispatch: {
76	claudeAgent: {	70	effort: "medium",
77	effort: "medium",
78	},
79	},	71	},
80	composerFrameClassName: "ultrathink-frame",	72	composerFrameClassName: "ultrathink-frame",
81	composerSurfaceClassName: "shadow-[0_0_0_1px_rgba(255,255,255,0.04)_inset]",	73	composerSurfaceClassName: "shadow-[0_0_0_1px_rgba(255,255,255,0.04)_inset]",
@@ -89,10 +81,8 @@ describe("getComposerProviderState", () => { · 7 unmodified lines
89	model: "claude-haiku-4-5",	81	model: "claude-haiku-4-5",
90	prompt: "",	82	prompt: "",
91	modelOptions: {	83	modelOptions: {
92	claudeAgent: {	84	effort: "max",
93	effort: "max",	85	thinking: false,
94	thinking: false,
95	},
96	},	86	},
97	});	87	});
98		88
@@ -100,50 +90,8 @@ describe("getComposerProviderState", () => { · 1 unmodified line
100	provider: "claudeAgent",	90	provider: "claudeAgent",
101	promptEffort: null,	91	promptEffort: null,
102	modelOptionsForDispatch: {	92	modelOptionsForDispatch: {
103	claudeAgent: {	93	thinking: false,
104	thinking: false,
105	},
106	},	94	},
107	});	95	});
108	});	96	});
109
110	it("ignores codex options while resolving Claude state", () => {
111	const state = getComposerProviderState({
112	provider: "claudeAgent",
113	model: "claude-opus-4-6",
114	prompt: "",
115	modelOptions: {
116	codex: {
117	reasoningEffort: "low",
118	fastMode: true,
119	},
120	},
121	});
122
123	expect(state).toEqual({
124	provider: "claudeAgent",
125	promptEffort: "high",
126	modelOptionsForDispatch: undefined,
127	});
128	});
129
130	it("ignores Claude options while resolving codex state", () => {
131	const state = getComposerProviderState({
132	provider: "codex",
133	model: "gpt-5.4",
134	prompt: "Ultrathink:\nThis should not matter",
135	modelOptions: {
136	claudeAgent: {
137	effort: "max",
138	fastMode: true,
139	},
140	},
141	});
142
143	expect(state).toEqual({
144	provider: "codex",
145	promptEffort: "high",
146	modelOptionsForDispatch: undefined,
147	});
148	});
149	});	97	});

apps/web/src/components/chat/composerProviderRegistry.tsx+27−13

 import {
+  type ClaudeModelOptions,
+  type CodexModelOptions,
   type ModelSlug,
+  type ModelSelection,
   type ProviderKind,
-  type ProviderModelOptions,
   type ThreadId,
 } from "@t3tools/contracts";
 import {
   provider: ProviderKind;
   model: ModelSlug;
   prompt: string;
-  modelOptions: ProviderModelOptions | null | undefined;
+  modelOptions: ModelSelection["options"] | null | undefined;
 };
 export type ComposerProviderState = {
   provider: ProviderKind;
   promptEffort: string | null;
-  modelOptionsForDispatch: ProviderModelOptions | undefined;
+  modelOptionsForDispatch: ModelSelection["options"] | undefined;
   composerFrameClassName?: string;
   composerSurfaceClassName?: string;
   modelPickerIconClassName?: string;
   }) => ReactNode;
 };
+function asCodexModelOptions(
+  modelOptions: ModelSelection["options"] | null | undefined,
+): CodexModelOptions | undefined {
+  return modelOptions && "reasoningEffort" in modelOptions ? modelOptions : undefined;
+}
+function asClaudeModelOptions(
+  modelOptions: ModelSelection["options"] | null | undefined,
+): ClaudeModelOptions | undefined {
+  return modelOptions && ("effort" in modelOptions || "thinking" in modelOptions)
+    ? modelOptions
+    : undefined;
+}
 const composerProviderRegistry: Record<ProviderKind, ProviderRegistryEntry> = {
   codex: {
     getState: ({ modelOptions }) => {
+      const codexModelOptions = asCodexModelOptions(modelOptions);
       const promptEffort =
-        resolveReasoningEffortForProvider("codex", modelOptions?.codex?.reasoningEffort) ??
+        resolveReasoningEffortForProvider("codex", codexModelOptions?.reasoningEffort) ??
         getDefaultReasoningEffort("codex");
-      const normalizedCodexOptions = normalizeCodexModelOptions(modelOptions?.codex);
+      const normalizedCodexOptions = normalizeCodexModelOptions(codexModelOptions);
       return {
         provider: "codex",
         promptEffort,
-        modelOptionsForDispatch: normalizedCodexOptions
+        modelOptionsForDispatch: normalizedCodexOptions,
-          ? { codex: normalizedCodexOptions }
-          : undefined,
       };
     },
     renderTraitsMenuContent: ({ threadId }) => <CodexTraitsMenuContent threadId={threadId} />,
   },
   claudeAgent: {
     getState: ({ model, prompt, modelOptions }) => {
+      const claudeModelOptions = asClaudeModelOptions(modelOptions);
       const reasoningOptions = getReasoningEffortOptions("claudeAgent", model);
       const draftEffort = resolveReasoningEffortForProvider(
         "claudeAgent",
-        modelOptions?.claudeAgent?.effort,
+        claudeModelOptions?.effort,
       );
       const defaultEffort = getDefaultReasoningEffort("claudeAgent");
       const promptEffort =
           : reasoningOptions.includes(defaultEffort)
             ? defaultEffort
             : null;
-      const normalizedClaudeOptions = normalizeClaudeModelOptions(model, modelOptions?.claudeAgent);
+      const normalizedClaudeOptions = normalizeClaudeModelOptions(model, claudeModelOptions);
       const ultrathinkActive =
         supportsClaudeUltrathinkKeyword(model) && isClaudeUltrathinkPrompt(prompt);
       return {
         provider: "claudeAgent",
         promptEffort,
-        modelOptionsForDispatch: normalizedClaudeOptions
+        modelOptionsForDispatch: normalizedClaudeOptions,
-          ? { claudeAgent: normalizedClaudeOptions }
-          : undefined,
         ...(ultrathinkActive ? { composerFrameClassName: "ultrathink-frame" } : {}),
         ...(ultrathinkActive
           ? { composerSurfaceClassName: "shadow-[0_0_0_1px_rgba(255,255,255,0.04)_inset]" }

packages/contracts/src/orchestration.ts+1−1

@@ -133,7 +133,7 @@ function normalizeLegacyThreadModelSelection( · 132 unmodified lines
133	return Effect.succeed(input.modelSelection);	133	return Effect.succeed(input.modelSelection);
134	}	134	}
135	if (input.model === undefined) {	135	if (input.model === undefined) {
136	return Effect.succeed(undefined);	136	return Effect.succeed<ModelSelection \| undefined>(undefined);
137	}	137	}
138	return Effect.try({	138	return Effect.try({
139	try: () =>	139	try: () =>

packages/contracts/src/provider.test.ts+46−24

       threadId: "thread-1",
       provider: "codex",
       cwd: "/tmp/workspace",
-      model: "gpt-5.3-codex",
+      modelSelection: {
-      modelOptions: {
+        provider: "codex",
-        codex: {
+        model: "gpt-5.3-codex",
+        options: {
           reasoningEffort: "high",
           fastMode: true,
         },
       },
     });
     expect(parsed.runtimeMode).toBe("full-access");
-    expect(parsed.modelOptions?.codex?.reasoningEffort).toBe("high");
+    expect(parsed.modelSelection?.provider).toBe("codex");
-    expect(parsed.modelOptions?.codex?.fastMode).toBe(true);
+    expect(parsed.modelSelection?.model).toBe("gpt-5.3-codex");
+    if (parsed.modelSelection?.provider !== "codex") {
+      throw new Error("Expected codex modelSelection");
+    }
+    expect(parsed.modelSelection.options?.reasoningEffort).toBe("high");
+    expect(parsed.modelSelection.options?.fastMode).toBe(true);
     expect(parsed.providerOptions?.codex?.binaryPath).toBe("/usr/local/bin/codex");
     expect(parsed.providerOptions?.codex?.homePath).toBe("/tmp/.codex");
   });
       threadId: "thread-1",
       provider: "claudeAgent",
       cwd: "/tmp/workspace",
-      model: "claude-sonnet-4-6",
+      modelSelection: {
-      modelOptions: {
+        provider: "claudeAgent",
-        claudeAgent: {
+        model: "claude-sonnet-4-6",
+        options: {
           thinking: true,
           effort: "max",
           fastMode: true,
       runtimeMode: "full-access",
     });
     expect(parsed.provider).toBe("claudeAgent");
-    expect(parsed.modelOptions?.claudeAgent?.thinking).toBe(true);
+    expect(parsed.modelSelection?.provider).toBe("claudeAgent");
-    expect(parsed.modelOptions?.claudeAgent?.effort).toBe("max");
+    expect(parsed.modelSelection?.model).toBe("claude-sonnet-4-6");
-    expect(parsed.modelOptions?.claudeAgent?.fastMode).toBe(true);
+    if (parsed.modelSelection?.provider !== "claudeAgent") {
+      throw new Error("Expected claude modelSelection");
+    }
+    expect(parsed.modelSelection.options?.thinking).toBe(true);
+    expect(parsed.modelSelection.options?.effort).toBe("max");
+    expect(parsed.modelSelection.options?.fastMode).toBe(true);
     expect(parsed.providerOptions?.claudeAgent?.binaryPath).toBe("/usr/local/bin/claude");
     expect(parsed.providerOptions?.claudeAgent?.permissionMode).toBe("plan");
     expect(parsed.providerOptions?.claudeAgent?.maxThinkingTokens).toBe(12_000);
 });
 describe("ProviderSendTurnInput", () => {
-  it("accepts provider-scoped model options", () => {
+  it("accepts codex modelSelection", () => {
     const parsed = decodeProviderSendTurnInput({
       threadId: "thread-1",
-      model: "gpt-5.3-codex",
+      modelSelection: {
-      modelOptions: {
+        provider: "codex",
-        codex: {
+        model: "gpt-5.3-codex",
+        options: {
           reasoningEffort: "xhigh",
           fastMode: true,
         },
       },
     });
-    expect(parsed.model).toBe("gpt-5.3-codex");
+    expect(parsed.modelSelection?.provider).toBe("codex");
-    expect(parsed.modelOptions?.codex?.reasoningEffort).toBe("xhigh");
+    expect(parsed.modelSelection?.model).toBe("gpt-5.3-codex");
-    expect(parsed.modelOptions?.codex?.fastMode).toBe(true);
+    if (parsed.modelSelection?.provider !== "codex") {
+      throw new Error("Expected codex modelSelection");
+    }
+    expect(parsed.modelSelection.options?.reasoningEffort).toBe("xhigh");
+    expect(parsed.modelSelection.options?.fastMode).toBe(true);
   });
-  it("accepts claude provider effort options including ultrathink", () => {
+  it("accepts claude modelSelection including ultrathink", () => {
     const parsed = decodeProviderSendTurnInput({
       threadId: "thread-1",
-      model: "claude-sonnet-4-6",
+      modelSelection: {
-      modelOptions: {
+        provider: "claudeAgent",
-        claudeAgent: {
+        model: "claude-sonnet-4-6",
+        options: {
           effort: "ultrathink",
           fastMode: true,
         },
       },
     });
-    expect(parsed.modelOptions?.claudeAgent?.effort).toBe("ultrathink");
+    expect(parsed.modelSelection?.provider).toBe("claudeAgent");
-    expect(parsed.modelOptions?.claudeAgent?.fastMode).toBe(true);
+    if (parsed.modelSelection?.provider !== "claudeAgent") {
+      throw new Error("Expected claude modelSelection");
+    }
+    expect(parsed.modelSelection.options?.effort).toBe("ultrathink");
+    expect(parsed.modelSelection.options?.fastMode).toBe(true);
   });
 });

packages/contracts/src/provider.ts+3−5

 import { Schema } from "effect";
 import { TrimmedNonEmptyString } from "./baseSchemas";
-import { ProviderModelOptions } from "./model";
 import {
   ApprovalRequestId,
   EventId,
 } from "./baseSchemas";
 import {
   ChatAttachment,
+  ModelSelection,
   PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
   PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
   ProviderApprovalDecision,
   threadId: ThreadId,
   provider: Schema.optional(ProviderKind),
   cwd: Schema.optional(TrimmedNonEmptyString),
-  model: Schema.optional(TrimmedNonEmptyString),
+  modelSelection: Schema.optional(ModelSelection),
-  modelOptions: Schema.optional(ProviderModelOptions),
   resumeCursor: Schema.optional(Schema.Unknown),
   approvalPolicy: Schema.optional(ProviderApprovalPolicy),
   sandboxMode: Schema.optional(ProviderSandboxMode),
   attachments: Schema.optional(
     Schema.Array(ChatAttachment).check(Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS)),
   ),
-  model: Schema.optional(TrimmedNonEmptyString),
+  modelSelection: Schema.optional(ModelSelection),
-  modelOptions: Schema.optional(ProviderModelOptions),
   interactionMode: Schema.optional(ProviderInteractionMode),
 });
 export type ProviderSendTurnInput = typeof ProviderSendTurnInput.Type;

packages/shared/src/model.test.ts+0−40

@@ -27,7 +27,6 @@ import { · 26 unmodified lines
27	supportsClaudeFastMode,	27	supportsClaudeFastMode,
28	supportsClaudeMaxEffort,	28	supportsClaudeMaxEffort,
29	supportsClaudeThinkingToggle,	29	supportsClaudeThinkingToggle,
30	toProviderModelOptions,
31	supportsClaudeUltrathinkKeyword,	30	supportsClaudeUltrathinkKeyword,
32	} from "./model";	31	} from "./model";
33		32
@@ -273,45 +272,6 @@ describe("normalizeClaudeModelOptions", () => { · 239 unmodified lines
273	});	272	});
274	});	273	});
275		274
276	describe("toProviderModelOptions", () => {
277	it("returns undefined when no model options exist", () => {
278	expect(toProviderModelOptions({ provider: "codex", model: "gpt-5.4" })).toBeUndefined();
279	expect(toProviderModelOptions(null)).toBeUndefined();
280	});
281
282	it("scopes codex options under the codex provider key", () => {
283	expect(
284	toProviderModelOptions({
285	provider: "codex",
286	model: "gpt-5.4",
287	options: {
288	fastMode: true,
289	},
290	}),
291	).toEqual({
292	codex: {
293	fastMode: true,
294	},
295	});
296	});
297
298	it("scopes claude options under the claudeAgent provider key", () => {
299	expect(
300	toProviderModelOptions({
301	provider: "claudeAgent",
302	model: "claude-opus-4-6",
303	options: {
304	effort: "max",
305	},
306	}),
307	).toEqual({
308	claudeAgent: {
309	effort: "max",
310	},
311	});
312	});
313	});
314
315	describe("supportsClaudeAdaptiveReasoning", () => {	275	describe("supportsClaudeAdaptiveReasoning", () => {
316	it("only enables adaptive reasoning for Opus 4.6 and Sonnet 4.6", () => {	276	it("only enables adaptive reasoning for Opus 4.6 and Sonnet 4.6", () => {
317	expect(supportsClaudeAdaptiveReasoning("claude-opus-4-6")).toBe(true);	277	expect(supportsClaudeAdaptiveReasoning("claude-opus-4-6")).toBe(true);

packages/shared/src/model.ts+0−13

@@ -10,9 +10,7 @@ import { · 9 unmodified lines
10	type ClaudeCodeEffort,	10	type ClaudeCodeEffort,
11	type CodexModelOptions,	11	type CodexModelOptions,
12	type CodexReasoningEffort,	12	type CodexReasoningEffort,
13	type ModelSelection,
14	type ModelSlug,	13	type ModelSlug,
15	type ProviderModelOptions,
16	type ProviderReasoningEffort,	14	type ProviderReasoningEffort,
17	type ProviderKind,	15	type ProviderKind,
18	} from "@t3tools/contracts";	16	} from "@t3tools/contracts";
@@ -268,15 +266,4 @@ export function applyClaudePromptEffortPrefix( · 249 unmodified lines
268	return `Ultrathink:\n${trimmed}`;	266	return `Ultrathink:\n${trimmed}`;
269	}	267	}
270		268
271	export function toProviderModelOptions(
272	modelSelection: ModelSelection \| null \| undefined,
273	): ProviderModelOptions \| undefined {
274	if (!modelSelection?.options) {
275	return undefined;
276	}
277	return modelSelection.provider === "codex"
278	? { codex: modelSelection.options }
279	: { claudeAgent: modelSelection.options };
280	}
281
282	export { CLAUDE_CODE_EFFORT_OPTIONS, CODEX_REASONING_EFFORT_OPTIONS };	269	export { CLAUDE_CODE_EFFORT_OPTIONS, CODEX_REASONING_EFFORT_OPTIONS };