bazis 0.96.1

package/core/infra/connectors/codex/contracts.ts

@@ -0,0 +1,82 @@
+export type CodexLoginMethod = "browser" | "device";
+export interface CodexLogin { id: string; method: CodexLoginMethod; url: string; userCode?: string; expiresAt: string }
+export interface CodexStatus {
+  configured: boolean; connected: boolean;
+  account: { email: string; planType: string } | null;
+  login: CodexLogin | null; loginError: string | null; activeRuns: number;
+}
+export interface CodexModel {
+  id: string; name: string; isDefault: boolean;
+  supportedReasoningEfforts: readonly { reasoningEffort: string; description: string }[];
+  defaultReasoningEffort: string | null;
+}
+export interface CodexChatMessage { role: "user" | "assistant"; text: string }
+export interface CodexTool {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+export interface CodexToolCall { readonly id: string; readonly name: string; readonly arguments: unknown; }
+export interface CodexToolResult { readonly text: string; readonly success: boolean; }
+export interface CodexRunInput {
+  model?: string; reasoningEffort?: string; instructions: string; messages: readonly CodexChatMessage[];
+  signal: AbortSignal; onTextDelta: (text: string) => void;
+  tools?: readonly CodexTool[];
+  onToolCall?: (call: CodexToolCall, signal: AbortSignal) => Promise<CodexToolResult>;
+}
+export interface CodexConfigShape { enabled: boolean; binary: string; stateDirectory: string }
+/** Narrow application API. Wire RPC, credentials and process handles are private. */
+export interface CodexClient {
+  status(): Promise<CodexStatus>;
+  login(method: CodexLoginMethod): Promise<CodexStatus>;
+  cancelLogin(): Promise<CodexStatus>;
+  logout(): Promise<CodexStatus>;
+  models(): Promise<readonly CodexModel[]>;
+  run(input: CodexRunInput): Promise<string>;
+}
+export type CodexErrorCode =
+  | "NOT_CONFIGURED" | "UNAVAILABLE" | "SIGN_IN_REQUIRED" | "BUSY" | "MODEL_UNAVAILABLE" | "REASONING_UNAVAILABLE"
+  | "PROTOCOL_ERROR" | "RESPONSE_FAILED" | "TIMEOUT" | "LOGIN_FAILED" | "LOGIN_EXPIRED";
+
+const EN_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freeze({
+  NOT_CONFIGURED: "The ChatGPT connection is not configured on the server.",
+  UNAVAILABLE: "Codex App Server is unavailable. Check its installation and settings.",
+  SIGN_IN_REQUIRED: "An administrator needs to connect a ChatGPT account.",
+  BUSY: "Wait until the current replies or the ChatGPT sign-in finish.",
+  MODEL_UNAVAILABLE: "The selected model is not available in the connected ChatGPT account.",
+  REASONING_UNAVAILABLE: "The selected reasoning level is not available for this model.",
+  PROTOCOL_ERROR: "Codex App Server returned an incompatible response.",
+  RESPONSE_FAILED: "ChatGPT did not finish the reply. Check the connection and the account limits.",
+  TIMEOUT: "Codex App Server timed out.",
+  LOGIN_FAILED: "ChatGPT sign-in failed. Try again; use device-code sign-in if needed.",
+  LOGIN_EXPIRED: "The sign-in window expired. Start signing in again.",
+});
+
+/** Russian texts for every code: `CodexError.useMessages(RU_CODEX_MESSAGES)` at startup. */
+export const RU_CODEX_MESSAGES: Readonly<Record<CodexErrorCode, string>> = Object.freeze({
+  NOT_CONFIGURED: "Подключение ChatGPT не настроено на сервере.",
+  UNAVAILABLE: "Codex App Server недоступен. Проверьте его установку и настройки.",
+  SIGN_IN_REQUIRED: "Администратору нужно подключить аккаунт ChatGPT.",
+  BUSY: "Дождитесь завершения текущих ответов или входа в ChatGPT.",
+  MODEL_UNAVAILABLE: "Выбранная модель недоступна в подключённом аккаунте ChatGPT.",
+  REASONING_UNAVAILABLE: "Выбранный уровень рассуждений недоступен для этой модели.",
+  PROTOCOL_ERROR: "Codex App Server вернул несовместимый ответ.",
+  RESPONSE_FAILED: "ChatGPT не завершил ответ. Проверьте подключение и лимиты аккаунта.",
+  TIMEOUT: "Время ожидания Codex App Server истекло.",
+  LOGIN_FAILED: "Не удалось войти в ChatGPT. Повторите вход; при необходимости используйте вход по коду.",
+  LOGIN_EXPIRED: "Время для входа истекло. Начните вход заново.",
+});
+
+let messages: Readonly<Record<CodexErrorCode, string>> = EN_CODEX_MESSAGES;
+
+/** `message` is user-facing text for `code`; switch its language with `useMessages`. */
+export class CodexError extends Error {
+  constructor(readonly code: CodexErrorCode) { super(messages[code]); this.name = "CodexError"; }
+
+  /** Replace texts for some or all codes (process-wide); missing codes keep English. */
+  static useMessages(overrides: Partial<Record<CodexErrorCode, string>>): void {
+    messages = Object.freeze({ ...EN_CODEX_MESSAGES, ...overrides });
+  }
+}
+export const CODEX_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,120}$/;
+export const CODEX_REASONING_EFFORT = /^[a-z][a-z0-9_-]{0,31}$/;

package/core/infra/connectors/codex.ts

@@ -0,0 +1,26 @@
+import { createToken, type InjectionToken } from "../../di";
+import type { AppConfig } from "../../kernel";
+import type { InfraConnector } from "../InfraConnector";
+import { reader, requireValue } from "../connectorConfig";
+import { CodexAppServerClient } from "./codex/CodexAppServerClient";
+import type { CodexClient, CodexConfigShape } from "./codex/contracts";
+
+export const CODEX_APP_SERVER: InjectionToken<CodexClient> = createToken<CodexClient>("CodexClient");
+
+/** App Server is a full executor; it does not implement the raw AgentModelProvider port. */
+export function codexAppServerConnect(config: AppConfig<CodexConfigShape>): InfraConnector<CodexClient> {
+  return {
+    token: CODEX_APP_SERVER, config, phase: 0,
+    create(configs) {
+      const view = reader(config, configs);
+      return new CodexAppServerClient({
+        enabled: view.get("enabled") as boolean,
+        binary: requireValue(view.get("binary"), "binary", "codex-app-server"),
+        stateDirectory: requireValue(view.get("stateDirectory"), "stateDirectory", "codex-app-server"),
+      });
+    },
+    connect(client, signal) { return (client as CodexAppServerClient).connect(signal); },
+    dispose(client) { return (client as CodexAppServerClient).dispose(); },
+    healthCheck(client, signal) { return (client as CodexAppServerClient).healthy(signal); },
+  };
+}

package/core/infra/connectors/llm.ts

@@ -0,0 +1,78 @@
+import type { AppConfig, ConfigRegistry, Secret } from "../../kernel";
+import { AGENT_MODEL_PROVIDER, type AgentModelProvider } from "../../agent";
+import { reader, requireValue } from "../connectorConfig";
+import { InfraError, type InfraConnector } from "../InfraConnector";
+import { identifyConnector } from "../connectorIdentity";
+
+/** Safe default for direct provider calls and health checks. */
+export const DEFAULT_LLM_REQUEST_TIMEOUT_MS = 60_000;
+
+export interface LlmConfigShape {
+  readonly provider: string;
+  readonly model: string;
+  readonly baseUrl: string;
+  readonly apiKey: Secret;
+}
+
+export interface LlmConnectionOptions {
+  readonly provider: string;
+  readonly model: string;
+  readonly baseUrl: string;
+  readonly apiKey: string;
+  /** Request timeout. Defaults to 60s; `0` explicitly disables it. */
+  readonly timeoutMs?: number;
+}
+
+export interface LlmConnectorOptions {
+  /** Request timeout. Defaults to 60s; `0` explicitly disables it. */
+  readonly timeoutMs?: number;
+}
+
+export interface LlmProviderAdapter {
+  create(options: LlmConnectionOptions): AgentModelProvider;
+  connect?(provider: AgentModelProvider, signal?: AbortSignal): Promise<void> | void;
+  dispose?(provider: AgentModelProvider): Promise<void> | void;
+  healthCheck?(provider: AgentModelProvider, signal?: AbortSignal): Promise<boolean> | boolean;
+}
+
+export function resolveLlmConnectionOptions<T extends LlmConfigShape>(
+  config: AppConfig<T>,
+  options: LlmConnectorOptions,
+  configs?: ConfigRegistry,
+): LlmConnectionOptions {
+  const c = reader(config, configs);
+  const configuredTimeout = options.timeoutMs ?? DEFAULT_LLM_REQUEST_TIMEOUT_MS;
+  if (!Number.isSafeInteger(configuredTimeout) || configuredTimeout < 0) {
+    throw new InfraError("llm timeoutMs must be a non-negative safe integer");
+  }
+  return {
+    provider: requireValue(c.get("provider"), "provider", "llm"),
+    model: requireValue(c.get("model"), "model", "llm"),
+    baseUrl: requireValue(c.get("baseUrl"), "baseUrl", "llm"),
+    apiKey: (c.get("apiKey") as Secret).reveal(),
+    timeoutMs: configuredTimeout,
+  };
+}
+
+export function llmConnect<T extends LlmConfigShape>(
+  config: AppConfig<T>,
+  adapter: LlmProviderAdapter,
+  options: LlmConnectorOptions = {},
+): InfraConnector<AgentModelProvider> {
+  return identifyConnector({
+    token: AGENT_MODEL_PROVIDER,
+    config,
+    create(configs) {
+      return adapter.create(resolveLlmConnectionOptions(config, options, configs));
+    },
+    connect(provider, signal) {
+      return adapter.connect?.(provider, signal);
+    },
+    dispose(provider) {
+      return adapter.dispose?.(provider);
+    },
+    healthCheck: adapter.healthCheck
+      ? (provider, signal) => adapter.healthCheck?.(provider, signal) ?? false
+      : undefined,
+  }, "llm");
+}

package/core/infra/connectors/llmRouter.ts

@@ -0,0 +1,443 @@
+import type { AppConfig } from "../../kernel";
+import {
+  AGENT_MODEL_PROVIDER,
+  agentModelRequest,
+  type AgentModelProvider,
+  type AgentModelProviderContext,
+  type AgentModelRequest,
+  type AgentModelResponse,
+} from "../../agent";
+import { InfraError, type InfraConnector } from "../InfraConnector";
+import { redactSensitiveText } from "../../../library/redaction";
+import { awaitAbortable } from "../../kernel/internal/awaitAbortable";
+import {
+  resolveLlmConnectionOptions,
+  type LlmConfigShape,
+  type LlmConnectionOptions,
+  type LlmConnectorOptions,
+  type LlmProviderAdapter,
+} from "./llm";
+
+export interface LlmModelProfileOptions extends LlmConnectorOptions {
+  readonly model?: string;
+  readonly temperature?: number;
+  readonly maxOutputTokens?: number;
+  readonly fallback?: string;
+}
+
+export interface LlmModelProfile<T extends LlmConfigShape = LlmConfigShape> {
+  readonly config: AppConfig<T>;
+  readonly adapter: LlmProviderAdapter;
+  readonly options: LlmModelProfileOptions;
+}
+
+export interface LlmRouterOptions {
+  readonly defaultProfile?: string;
+}
+
+interface RuntimeProfile {
+  readonly name: string;
+  readonly adapter: LlmProviderAdapter;
+  readonly provider: AgentModelProvider;
+  readonly connection: LlmConnectionOptions;
+  readonly options: LlmModelProfileOptions;
+}
+
+export class LlmModelRouterError extends Error {
+  public constructor(message: string) {
+    super(message);
+    this.name = "LlmModelRouterError";
+  }
+}
+
+function nonEmptyText(value: string | undefined, field: string): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new InfraError(`${field} must be a non-empty string when provided.`);
+  }
+  return trimmed;
+}
+
+function profileEntries(profiles: Readonly<Record<string, LlmModelProfile>>): readonly (readonly [string, LlmModelProfile])[] {
+  const entries = Object.entries(profiles).map(([name, profile]) => [
+    name,
+    Object.freeze({ ...profile, options: normalizeProfileOptions(profile.options, `llmRouter.${name}`) }),
+  ] as const);
+  if (entries.length === 0) {
+    throw new InfraError("llmRouter requires at least one model profile.");
+  }
+  for (let index = 0; index < entries.length; index += 1) {
+    const [name] = entries[index] as [string, LlmModelProfile];
+    const normalized = nonEmptyText(name, `llmRouter.profile[${index}]`);
+    if (normalized !== name) {
+      throw new InfraError(`llmRouter profile name "${name}" must not have surrounding whitespace.`);
+    }
+  }
+  return Object.freeze(entries);
+}
+
+function defaultProfileName(
+  entries: readonly (readonly [string, LlmModelProfile])[],
+  options: LlmRouterOptions,
+): string {
+  const requested = nonEmptyText(options.defaultProfile, "llmRouter.defaultProfile");
+  if (requested !== undefined) {
+    if (!entries.some(([name]) => name === requested)) {
+      throw new InfraError(`llmRouter defaultProfile "${requested}" is not registered.`);
+    }
+    return requested;
+  }
+  if (entries.length === 1) {
+    return entries[0]![0];
+  }
+  if (entries.some(([name]) => name === "default")) {
+    return "default";
+  }
+  throw new InfraError("llmRouter with multiple profiles requires defaultProfile or a profile named \"default\".");
+}
+
+function ensureFallbacksValid(entries: readonly (readonly [string, LlmModelProfile])[]): void {
+  const names = new Set(entries.map(([name]) => name));
+  for (let index = 0; index < entries.length; index += 1) {
+    const [name, profile] = entries[index] as readonly [string, LlmModelProfile];
+    const fallback = nonEmptyText(profile.options.fallback, `llmRouter.${name}.fallback`);
+    if (fallback === undefined) {
+      continue;
+    }
+    if (fallback === name) {
+      throw new InfraError(`llmRouter profile "${name}" cannot fallback to itself.`);
+    }
+    if (!names.has(fallback)) {
+      throw new InfraError(`llmRouter profile "${name}" fallback "${fallback}" is not registered.`);
+    }
+  }
+
+  const state = new Map<string, "visiting" | "visited">();
+  const path: string[] = [];
+  const visit = (name: string): void => {
+    if (state.get(name) === "visited") {
+      return;
+    }
+    if (state.get(name) === "visiting") {
+      const start = path.indexOf(name);
+      const cycle = [...path.slice(start), name];
+      throw new InfraError(`llmRouter fallback cycle detected: ${cycle.join(" -> ")}.`);
+    }
+    state.set(name, "visiting");
+    path.push(name);
+    const fallback = entries.find(([entryName]) => entryName === name)?.[1].options.fallback;
+    if (fallback !== undefined) {
+      visit(fallback);
+    }
+    path.pop();
+    state.set(name, "visited");
+  };
+  for (const [name] of entries) {
+    visit(name);
+  }
+}
+
+function errorMessageOf(error: unknown): string {
+  return redactSensitiveText(error instanceof Error ? error.message : String(error));
+}
+
+function positiveInteger(value: number | undefined, field: string): number | undefined {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new InfraError(`${field} must be a positive integer when provided.`);
+  }
+  return value;
+}
+
+function nonNegativeInteger(value: number | undefined, field: string): number | undefined {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new InfraError(`${field} must be a non-negative safe integer when provided.`);
+  }
+  return value;
+}
+
+function finiteNumber(value: number | undefined, field: string): number | undefined {
+  if (value !== undefined && !Number.isFinite(value)) {
+    throw new InfraError(`${field} must be finite when provided.`);
+  }
+  return value;
+}
+
+function normalizeProfileOptions(options: LlmModelProfileOptions, field: string): LlmModelProfileOptions {
+  const model = nonEmptyText(options.model, `${field}.model`);
+  const fallback = nonEmptyText(options.fallback, `${field}.fallback`);
+  nonNegativeInteger(options.timeoutMs, `${field}.timeoutMs`);
+  positiveInteger(options.maxOutputTokens, `${field}.maxOutputTokens`);
+  finiteNumber(options.temperature, `${field}.temperature`);
+  return Object.freeze({
+    ...options,
+    ...(model === undefined ? {} : { model }),
+    ...(fallback === undefined ? {} : { fallback }),
+  });
+}
+
+export function llmProfile<T extends LlmConfigShape>(
+  config: AppConfig<T>,
+  adapter: LlmProviderAdapter,
+  options: LlmModelProfileOptions = {},
+): LlmModelProfile<T> {
+  return Object.freeze({ config, adapter, options: normalizeProfileOptions(options, "llmProfile") });
+}
+
+export class LlmModelRouter implements AgentModelProvider {
+  private readonly profiles = new Map<string, RuntimeProfile>();
+  private connectPromise?: Promise<void>;
+  private initializePromise?: Promise<void>;
+  private disposePromise?: Promise<void>;
+  private disposed = false;
+
+  public constructor(
+    profiles: readonly RuntimeProfile[],
+    private readonly defaultProfile: string,
+    private readonly factories: readonly (() => RuntimeProfile)[] = [],
+  ) {
+    for (let index = 0; index < profiles.length; index += 1) {
+      const profile = profiles[index] as RuntimeProfile;
+      this.profiles.set(profile.name, profile);
+    }
+  }
+
+  public async complete(request: AgentModelRequest, context: AgentModelProviderContext): Promise<AgentModelResponse> {
+    context.signal.throwIfAborted();
+    await this.initialize();
+    const requested = request.modelProfile ?? context.modelProfile ?? this.defaultProfile;
+    return this.completeWithProfile(request, context, requested, new Set<string>());
+  }
+
+  public connect(signal?: AbortSignal): Promise<void> {
+    if (this.disposed) {
+      return Promise.reject(new InfraError("LLM model router is already disposed."));
+    }
+    this.connectPromise ??= this.connectProfiles(signal);
+    return this.connectPromise;
+  }
+
+  private async connectProfiles(signal?: AbortSignal): Promise<void> {
+    signal?.throwIfAborted();
+    await this.initialize();
+    for (const profile of this.profiles.values()) {
+      try {
+        if (this.disposed) throw new InfraError("LLM model router is already disposed.");
+        signal?.throwIfAborted();
+        await awaitAbortable(Promise.resolve(profile.adapter.connect?.(profile.provider, signal)), signal);
+      } catch (error) {
+        const primary = new InfraError(
+          `LLM model profile "${profile.name}" failed to connect: ${errorMessageOf(error)}`,
+        );
+        try {
+          await this.dispose();
+        } catch (cleanupError) {
+          const cleanupErrors =
+            cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError];
+          throw new AggregateError(
+            [primary, ...cleanupErrors],
+            `LLM model router failed to connect and rollback finished with errors.`,
+          );
+        }
+        throw primary;
+      }
+    }
+  }
+
+  private initialize(): Promise<void> {
+    if (this.disposed) return Promise.reject(new InfraError("LLM model router is already disposed."));
+    this.initializePromise ??= Promise.resolve().then(async () => {
+      try {
+        if (this.disposed) throw new InfraError("LLM model router is already disposed.");
+        for (const create of this.factories) {
+          const profile = create();
+          this.profiles.set(profile.name, profile);
+        }
+      } catch (error) {
+        const primary = new InfraError(`LLM model router failed to create profiles: ${errorMessageOf(error)}`);
+        try {
+          await this.dispose();
+        } catch (cleanupError) {
+          throw new AggregateError([primary, cleanupError], "LLM model router creation and rollback failed.");
+        }
+        throw primary;
+      }
+    });
+    return this.initializePromise;
+  }
+
+  public dispose(): Promise<void> {
+    if (this.disposePromise !== undefined) {
+      return this.disposePromise;
+    }
+    if (this.disposed) {
+      return Promise.resolve();
+    }
+    this.disposed = true;
+    const work = Promise.resolve().then(() => this.disposeProfiles());
+    this.disposePromise = work;
+    const clear = (): void => {
+      this.disposePromise = undefined;
+    };
+    void work.then(clear, clear);
+    return work;
+  }
+
+  private async disposeProfiles(): Promise<void> {
+    const errors: unknown[] = [];
+    const profiles = Array.from(this.profiles.values()).reverse();
+    for (let index = 0; index < profiles.length; index += 1) {
+      const profile = profiles[index] as RuntimeProfile;
+      try {
+        await profile.adapter.dispose?.(profile.provider);
+      } catch (error) {
+        errors.push(new InfraError(
+          `LLM model profile "${profile.name}" failed to dispose: ${errorMessageOf(error)}`,
+        ));
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, "LLM model router disposal finished with errors.");
+    }
+  }
+
+  public async healthCheck(signal?: AbortSignal): Promise<boolean> {
+    if (this.disposed) {
+      return false;
+    }
+    await this.initialize();
+    let healthy = true;
+    for (const profile of this.profiles.values()) {
+      if (profile.adapter.healthCheck) {
+        try {
+          signal?.throwIfAborted();
+          if (!(await awaitAbortable(Promise.resolve(profile.adapter.healthCheck(profile.provider, signal)), signal))) {
+            healthy = false;
+          }
+        } catch {
+          healthy = false;
+          if (signal?.aborted) return false;
+        }
+      }
+    }
+    return healthy;
+  }
+
+  private async completeWithProfile(
+    request: AgentModelRequest,
+    context: AgentModelProviderContext,
+    profileName: string,
+    visited: Set<string>,
+  ): Promise<AgentModelResponse> {
+    if (visited.has(profileName)) {
+      throw new LlmModelRouterError(`LLM model profile fallback cycle detected at "${profileName}".`);
+    }
+    visited.add(profileName);
+
+    const profile = this.profiles.get(profileName);
+    if (!profile) {
+      throw new LlmModelRouterError(`Unknown LLM model profile "${profileName}".`);
+    }
+    if (context.signal.aborted) {
+      throw new LlmModelRouterError("LLM model request was cancelled before provider dispatch.");
+    }
+
+    let emittedText = false, acceptingText = true;
+    const streamingContext = context.onTextDelta ? { ...context, onTextDelta: (text: string) => {
+      if (!acceptingText || context.signal.aborted) return;
+      if (text) emittedText = true;
+      context.onTextDelta!(text);
+    } } : context;
+    try {
+      return await profile.provider.complete(this.requestForProfile(request, profile), this.contextForProfile(streamingContext, profileName));
+    } catch (error) {
+      acceptingText = false;
+      const fallback = profile.options.fallback;
+      // A second model must not silently append a new answer to already visible text.
+      if (fallback !== undefined && !emittedText) {
+        if (context.signal.aborted) throw new LlmModelRouterError("LLM model request was cancelled before provider dispatch.");
+        return this.completeWithProfile(request, context, fallback, visited);
+      }
+      throw new LlmModelRouterError(
+        `LLM model profile "${profileName}" failed: ${errorMessageOf(error)}`,
+      );
+    } finally {
+      acceptingText = false;
+    }
+  }
+
+  private requestForProfile(request: AgentModelRequest, profile: RuntimeProfile): AgentModelRequest {
+    return agentModelRequest({
+      invocationId: request.invocationId,
+      messages: request.messages,
+      tools: request.tools,
+      output: request.output,
+      capabilities: request.capabilities,
+      modelProfile: profile.name,
+      // Model identity belongs to infra/profile policy. Invocation input may
+      // tune sampling/limits but cannot bypass the selected profile's model.
+      model: profile.options.model ?? profile.connection.model,
+      maxOutputTokens: request.maxOutputTokens ?? profile.options.maxOutputTokens,
+      temperature: request.temperature ?? profile.options.temperature,
+      metadata: { ...request.metadata, modelProfile: profile.name },
+    });
+  }
+
+  private contextForProfile(context: AgentModelProviderContext, profileName: string): AgentModelProviderContext {
+    return Object.freeze({
+      ...context,
+      modelProfile: profileName,
+    });
+  }
+}
+
+export function llmRouter(
+  profiles: Readonly<Record<string, LlmModelProfile>>,
+  options: LlmRouterOptions = {},
+): InfraConnector<AgentModelProvider> {
+  const entries = profileEntries(profiles);
+  const defaultProfile = defaultProfileName(entries, options);
+  ensureFallbacksValid(entries);
+  const configs = Object.freeze(Array.from(new Set(entries.map(([, profile]) => profile.config))));
+
+  return {
+    token: AGENT_MODEL_PROVIDER,
+    config: configs,
+    create(configs) {
+      // The router must have an owner before adapters allocate resources.
+      // Initialization happens inside an awaited operation, so rollback can
+      // await asynchronous adapter disposal and preserve cleanup errors.
+      const factories = entries.map(([name, profile]) => () => {
+        const connection = resolveLlmConnectionOptions(profile.config, profile.options, configs);
+        // A profile-owned model is part of the concrete Infra connection. This
+        // keeps direct providers strict while the router remains the authority
+        // that selects the active profile/model pair.
+        const profileConnection = profile.options.model === undefined
+          ? connection
+          : Object.freeze({ ...connection, model: profile.options.model });
+        return Object.freeze({
+          name,
+          adapter: profile.adapter,
+          provider: profile.adapter.create(profileConnection),
+          connection: profileConnection,
+          options: profile.options,
+        });
+      });
+      return new LlmModelRouter([], defaultProfile, factories);
+    },
+    connect(client, signal) {
+      return client instanceof LlmModelRouter ? client.connect(signal) : undefined;
+    },
+    dispose(client) {
+      return client instanceof LlmModelRouter ? client.dispose() : undefined;
+    },
+    healthCheck(client, signal) {
+      return client instanceof LlmModelRouter ? client.healthCheck(signal) : false;
+    },
+  };
+}