the reasoning level. A fresh `openagents coder` session with no `--model`

  runs as `Coder Auto`: its thread is opened unpinned and the inference proxy

  request names no model, so the server selects the lane per call.

- A tier is checked against what the server says it can answer before a thread

  opens on it. `tierUnavailable` reads the same `/api/v1/models` catalog and

  the same `availability` field that `chooseBackend` applies to the model a

  session opens with, so shift+tab cannot strand a reader on a lane the

  deployment cannot serve. A refused tier keeps the session on the tier that

  was answering and names the tiers that can answer. The rename is why this

  matters: a reader who saw a vendor id fail could search for it, and a reader

  who sees `Coder Flash` fail has been told nothing. Where the catalog could

  not be read the tier is allowed, because "could not ask" is not "serves

  nothing"; `Coder Local` is never refused here, since it answers from the

  reader's machine rather than the deployment.

- Availability is the only claim a tier makes. No tier is presented as cheaper

  or dearer than another: the catalog declares a rate for some lanes and none

  for others, and a tier label implying a price the server never quoted would

  be a worse lie than the vendor name it replaced.

- Held by `packages/openagents-cli/test/coder-tiers.test.ts`. Issue

  OpenAgentsInc/openagents#40.

import { CoderSession, DummyReplySource } from "./coder-session.js";

import { CoderTaskRegistry } from "./coder-tasks.js";

import { runCoderUi } from "./coder-ui.js";

import {

  backendIds,

  chooseBackend,

  fetchServedCatalog,

  refuseBackend,

} from "./coder-backends.js";

import { backendIds, chooseBackend, fetchServedCatalog, refuseBackend } from "./coder-backends.js";

import {

  discoverOllamaModel,

  isOllamaModelFlag,

import { rebuild, RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

import { loadSkillSelection, standingContext } from "./coder-skills.js";

import { startDevServer } from "./coder-dev-server.js";

import { TIER_MODELS, tierForModel, type CoderTierId } from "./coder-tiers.js";

import { TIER_MODELS, tierForModel, tierUnavailable, type CoderTierId } from "./coder-tiers.js";

import { ZenReplySource, zenCredential } from "./coder-zen.js";

import { describeWorkspace } from "./coder-workspace.js";

import { ComputerClient } from "./computer-client.js";

        // different agent under the name the caller asked for.

        new SelfHarness({ grant: nonNullGrant(options.grant) })

      : /^claude(:.+)?$/.test(choice)

        ? new ClaudeCodeHarness(

            choice.startsWith("claude:") ? { model: choice.slice(7) } : {},

          )

        ? new ClaudeCodeHarness(choice.startsWith("claude:") ? { model: choice.slice(7) } : {})

        : /^devin(:.+)?$/.test(choice)

          ? new DevinHarness(choice.startsWith("devin:") ? { permissionMode: choice.slice(6) } : {})

          : /^codex(:.+)?$/.test(choice)

            ? new CodexHarness(

                choice.startsWith("codex:") ? { model: choice.slice(6) } : {},

              )

            ? new CodexHarness(choice.startsWith("codex:") ? { model: choice.slice(6) } : {})

            : new OpencodeHarness({

                model: choice,

                ...(command === undefined ? {} : { command }),

        : async (tier: CoderTierId, history: ReadonlyArray<unknown>): Promise<ReplySource> => {

            const accountToken = Redacted.value(stored.value.token);

            const carried = history as ReadonlyArray<WireMessage>;

            // A tier this deployment cannot answer is refused before a thread

            // is opened on it. Throwing here is what keeps the session on the

            // tier that was answering: `applyPendingTier` catches it, says

            // why, and does not switch. Opening the thread anyway would spend

            // the switch to reach a lane that fails at its first turn, under a

            // friendly name that tells the reader nothing.

            const unavailable = tierUnavailable(served, tier);

            if (unavailable !== undefined) throw new Error(unavailable);

            if (tier === "local") {

              const name = await discoverOllamaModel(process.env["OLLAMA_HOST"] ?? undefined);

              if (name === undefined) {

      const foreignSessionsManifest = locateForeignSessionsManifest();

      const runForeignSessionResume = async (

        selection: number | undefined,

      ): Promise<string> => {

      const runForeignSessionResume = async (selection: number | undefined): Promise<string> => {

        if (foreignSessionsManifest === undefined) {

          return (

            "The foreign session scanner is not available from this installation. " +

            );

          }

        };

        return runForeignResume(

          { now_ms: Date.now(), cwd: process.cwd(), selection },

          invoke,

        );

        return runForeignResume({ now_ms: Date.now(), cwd: process.cwd(), selection }, invoke);

      };

      // Only when there is really no way to run a child. A refused child

  return tier === undefined ? "Coder" : LABELS[tier];

};

/** One lane of the served catalog, as much of it as a tier decision needs. */

interface ServedLane {

  readonly id: string;

  readonly available: boolean;

}

/**

 * Why this tier cannot open a thread on this deployment, or `undefined` if it

 * can.

 *

 * A tier is a friendlier name than a vendor id, which makes it a better place

 * to hide a dead lane — the reader who used to see `gemini-3.7-flash` fail

 * could at least search for it, while a reader who sees `Coder Flash` fail has

 * been told nothing. So the tier a reader picks is checked against what the

 * server says it can answer, the same catalog and the same `available` reading

 * that `chooseBackend` already applies to the model a session opens with. The

 * refusal names tiers only, because the invariant does not lapse when the news

 * is bad.

 *

 * `undefined` for `served` means the catalog could not be read — an older

 * server, an unreachable one, a resumed session that never asked. That is not

 * the same as "serves nothing", so the tier is allowed and the turn reports

 * the truth. `Coder Local` is never refused here: it answers from this machine

 * rather than this deployment, and its own discovery says so when no local

 * server is running.

 *

 * Availability is the only claim made. No tier is described as cheaper or

 * dearer than another: the catalog declares a rate for some lanes and none for

 * others, and a tier label that implied a price the server never quoted would

 * be a worse lie than the vendor name it replaced.

 */

export const tierUnavailable = (

  served: ReadonlyArray<ServedLane> | undefined,

  tier: CoderTierId,

): string | undefined => {

  if (served === undefined || tier === "local") return undefined;

  const answering = (id: string): boolean =>

    served.some((lane) => lane.id === id && lane.available);

  // Auto is openable whenever anything is, because it names no model and lets

  // the server pick the lane per call.

  const openable: CoderTierId[] = [];

  if (served.some((lane) => lane.available)) openable.push("auto");

  if (answering(TIER_MODELS.flash)) openable.push("flash");

  if (answering(TIER_MODELS.pro)) openable.push("pro");

  if (openable.includes(tier)) return undefined;

  // A reason clause, not a sentence: the caller that reports this already

  // names the tier that could not be had, and saying it twice reads as a

  // stutter. It still names the tiers that *can* answer, because a refusal

  // that leaves the reader guessing which way to press shift+tab has only

  // half done the job.

  return openable.length === 0

    ? `no lane on this deployment has a configured provider credential. ` +

        `${tierLabel("local")} still runs on this machine.`

    : `this deployment is not serving that lane right now. ` +

        `Available: ${openable.map(tierLabel).join(", ")}, and ` +

        `${tierLabel("local")} on this machine.`;

};

/** Shift+Tab's orbit: Auto → Flash → Pro → Local → Auto. */

export const nextTier = (tier: CoderTierId): CoderTierId => {

  switch (tier) {

  TIER_MODELS,

  tierForModel,

  tierLabel,

  tierUnavailable,

} from "../src/coder-tiers.js";

// The invariant (INVARIANTS.md "Coder Model Naming"): a vendor model name

    }

  });

  it("opens a tier whose lane the server says is available", () => {

    const served = [

      { id: TIER_MODELS.flash, available: true },

      { id: TIER_MODELS.pro, available: true },

    ];

    expect(tierUnavailable(served, "auto")).toBeUndefined();

    expect(tierUnavailable(served, "flash")).toBeUndefined();

    expect(tierUnavailable(served, "pro")).toBeUndefined();

  });

  it("refuses a tier whose lane the server serves but cannot answer on", () => {

    const served = [

      { id: TIER_MODELS.flash, available: false },

      { id: TIER_MODELS.pro, available: true },

    ];

    // The dead lane is refused; the live one and Auto still open. This is the

    // case the tier rename could have buried: `Coder Flash` is a friendlier

    // name to fail under than the vendor id a reader could have searched for.

    // The refusal points at the tiers that can answer.

    expect(tierUnavailable(served, "flash")).toContain("Coder Pro");

    expect(tierUnavailable(served, "flash")).not.toContain("Coder Flash");

    expect(tierUnavailable(served, "pro")).toBeUndefined();

    expect(tierUnavailable(served, "auto")).toBeUndefined();

  });

  it("refuses a tier this deployment does not serve at all", () => {

    const served = [{ id: TIER_MODELS.pro, available: true }];

    expect(tierUnavailable(served, "flash")).toContain("not serving that lane");

  });

  it("says Auto cannot select when no lane on the deployment can answer", () => {

    const served = [

      { id: TIER_MODELS.flash, available: false },

      { id: TIER_MODELS.pro, available: false },

    ];

    for (const tier of ["auto", "flash", "pro"] as const) {

      expect(tierUnavailable(served, tier)).toContain("no lane on this deployment");

    }

  });

  it("allows every tier when the catalog could not be read", () => {

    // Not the same as "serves nothing": an unreachable or older server is a

    // reason to let the turn report the truth, not to refuse up front.

    for (const tier of ["auto", "flash", "pro", "local"] as const) {

      expect(tierUnavailable(undefined, tier)).toBeUndefined();

    }

  });

  it("never refuses Coder Local, which answers from this machine", () => {

    expect(tierUnavailable([], "local")).toBeUndefined();

    expect(tierUnavailable([{ id: TIER_MODELS.pro, available: false }], "local")).toBeUndefined();

  });

  it("names no vendor model and quotes no price when it refuses", () => {

    const served = [

      { id: TIER_MODELS.flash, available: false },

      { id: TIER_MODELS.pro, available: false },

    ];

    for (const tier of ["auto", "flash", "pro"] as const) {

      const refusal = tierUnavailable(served, tier);

      expect(refusal).toBeDefined();

      // The invariant does not lapse when the news is bad.

      for (const id of [TIER_MODELS.flash, TIER_MODELS.pro, "ox-alpha", "gemini", "gpt", "ollama"])

        expect(refusal).not.toContain(id);

      // Availability is the only claim. A tier carries no price comparison,

      // because the catalog declares a rate for some lanes and none for

      // others.

      for (const priced of ["cheap", "cheaper", "free", "$", "per million", "cost"])

        expect(refusal?.toLowerCase()).not.toContain(priced);

    }

  });

  it("never leaks a vendor id through any label", () => {

    for (const id of [

      TIER_MODELS.flash,

    expect(session.cycleTier().label).toBe("Coder Local");

    expect(session.cycleTier().label).toBe("Coder Auto");

  });

  // What `tierUnavailable` is for, end to end: the build throws for a lane the

  // deployment cannot answer, and the session stays on the tier that was

  // answering rather than stranding the reader on a dead one.

  it("stays on the answering tier when the next tier cannot be built", async () => {

    const refusal = tierUnavailable(

      [

        { id: TIER_MODELS.flash, available: false },

        { id: TIER_MODELS.pro, available: true },

      ],

      "flash",

    );

    expect(refusal).toBeDefined();

    const session = new CoderSession(silent, "repo", "main", undefined, undefined, undefined, {

      initial: "auto",

      build: (tier) =>

        tier === "flash" ? Promise.reject(new Error(refusal)) : Promise.resolve(silent),

    });

    session.cycleTier();

    // The label flips optimistically; the build decides whether it holds.

    expect(session.snapshot().model).toBe("Coder Flash");

    await session.submit("hello");

    // The refused tier did not take, and the reader was told which tier it

    // was and where to go instead — without a vendor name.

    expect(session.snapshot().model).toBe("Coder Auto");

    const notices = session

      .snapshot()

      .entries.filter((entry) => entry.role === "notice")

      .map((entry) => entry.text)

      .join("\n");

    expect(notices).toContain("Coder Flash is not available");

    expect(notices).toContain("Coder Pro");

    expect(notices).not.toContain(TIER_MODELS.flash);

  });

});