@skaile/forge-settings 2.0.2 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2.1.0
+
+### Minor Changes
+
+- ce96a12: The registry model adapter no longer depends on `@skaile/forge-editor`. It moves to the editor-neutral entry `/model-provider` and declares its own `ModelProfile`, `ModelRef` and `ModelProvider` types, which match the editor's `models` port structurally; a host assigns `createModelProvider(...)` to `ports.models` and its typecheck checks the fit. `@skaile/forge-editor` is no longer a peer or dev dependency.
+  
+  `/editor` stays as a deprecated entry with the old names and goes with the next major. Migrate to `/model-provider`:
+  
+  - `createEditorModelProvider(options)` → `createModelProvider(options)`
+  - `editorLanguageModel(registry, env, ref, options)` → `registryLanguageModel(registry, env, ref, options)`
+  - `listEditorModelProfiles(registry, env, options)` → `listModelProfiles(registry, env, options)`
+  - `editorModelProfiles(registry, options)` → `declaredModelProfiles(registry, options)`
+  - Types `EditorModelPolicyOptions` → `ModelPolicyOptions`, `EditorModelProviderOptions` → `ModelProviderOptions`; `ModelProfile`, `ModelRef` and `ModelProvider` come from `/model-provider` instead of `@skaile/forge-editor/ai`.
+
 ## 2.0.2
 
 ### Patch Changes

package/README.md

@@ -8,10 +8,11 @@ Provider and settings operations for Skaile forge apps, without the app's databa
 | `/vue` | `useProvidersPanel`, `urlProvidersClient`, `SettingsModalScope`, model-role helpers, browser-safe registry/env/harness vocabulary | `vue` |
 | `/nuxt` | Nuxt module registering `<ForgeProvidersPanel>` and `<ForgeModelRolesPanel>` | `nuxt`, `@nuxt/ui` |
 | `/ai-sdk` | AI SDK `LanguageModel` of a registry selector | `ai` + the `@ai-sdk/*` provider the surface needs |
-| `/editor` | the editor's `ModelProvider` over a registry | `@skaile/forge-editor`, `ai`, the `@ai-sdk/*` provider the surface needs |
+| `/model-provider` | a `ModelProvider` (`listModels`, `languageModel`) over a registry, with its own `ModelProfile` / `ModelRef` types | `ai` + the `@ai-sdk/*` provider the surface needs |
+| `/editor` | deprecated: the `/model-provider` exports under their 2.0 names (`createEditorModelProvider`, `editorModelProfiles`, `listEditorModelProfiles`, `editorLanguageModel`); removed in the next major | as `/model-provider` |
 | `/workspaces` | Skaile Workspaces integration: `SkaileSettings`, `SETTINGS_DEFAULTS`, legacy settings migrations, harness settings rules, `workspaceCredentialStorePath`, `resolveWorkspaceLanguageModel`, `readWorkspaceModelEndpoint` | `@skaile/workspaces` |
 
-The registry schema, catalog, discovery and model constructor come from `@skaile/provider-registry` (a dependency). Importing `/server` loads no Vue, editor, AI SDK, agent session code or Skaile Workspaces. Every peer is optional and used by one entry only: `/server`, `/vue`, `/nuxt`, `/ai-sdk` and `/editor` install, load and typecheck without `@skaile/workspaces`; only `/workspaces` needs it.
+The registry schema, catalog, discovery and model constructor come from `@skaile/provider-registry` (a dependency). Importing `/server` loads no Vue, editor, AI SDK, agent session code or Skaile Workspaces. Every peer is optional and used by one entry only: `/server`, `/vue`, `/nuxt`, `/ai-sdk` and `/model-provider` install, load and typecheck without `@skaile/workspaces`; only `/workspaces` needs it.
 
 ## What stays with the host
 
@@ -50,13 +51,13 @@ There is no implicit store location. The file is `options.path`, else `FORGE_CRE
 
 Any entry with `discovery: { type: 'openai-models-list' }` (or an OpenAI/Anthropic surface) is asked at its own `base_url`, with its static `headers` and its credential exactly as inference sends them — no catalog preset needed. `credential.kind: 'none'` queries without `Authorization`, so a local model server works keyless. The credential is resolved under the policy first: a refused or unresolvable reference sends no request.
 
-## Models for the editor and the AI SDK
+## Model provider and the AI SDK
 
 ```ts
-// server/utils/editor-models.ts: ModelProvider for @skaile/forge-editor
-import { createEditorModelProvider, ModelResolutionError } from '@skaile/forge-settings/editor'
+// server/utils/models.ts: the host's model provider over its registry
+import { createModelProvider, ModelResolutionError } from '@skaile/forge-settings/model-provider'
 
-export const models = createEditorModelProvider({
+export const models = createModelProvider({
   registry: () => getProviderRegistry(home()),
   env: () => effectiveEnv(),
   policy,                                            // refused entries are neither listed nor resolved
@@ -65,7 +66,9 @@ export const models = createEditorModelProvider({
 })
 ```
 
-`listModels` answers the declared models (`model_map` / `capabilities`) plus the models each entry's models list reports, one profile per selector (a declared identity wins over a discovered duplicate). Declared models work without a models list. The registry is authoritative: an empty one lists `[]`, and a selector whose provider id is a registry entry either resolves or throws (disabled, refused, unresolvable) — only a selector the registry does not own (or a browser `{ endpoint, model, apiKey }` reference) answers `null` and falls through to the editor's presets. `editorModelProfiles(registry, { policy? })` is the declared-only, network-free list; `await editorLanguageModel(registry, env, ref, options)` is the adapter's model lookup.
+The entry defines its own `ModelProfile`, `ModelRef` and `ModelProvider` types and depends on no consumer. They match a host's model port structurally (for example an editor's `models` port, a chat handler or an agent runtime): the host assigns `createModelProvider(...)` to its port, and its own typecheck verifies the fit.
+
+`listModels` answers the declared models (`model_map` / `capabilities`) plus the models each entry's models list reports, one profile per selector (a declared identity wins over a discovered duplicate). Declared models work without a models list. The registry is authoritative: an empty one lists `[]`, and a selector whose provider id is a registry entry either resolves or throws (disabled, refused, unresolvable) — only a selector the registry does not own (or a browser `{ endpoint, model, apiKey }` reference) answers `null` and falls through to the host's own models. `declaredModelProfiles(registry, { policy? })` is the declared-only, network-free list; `await listModelProfiles(registry, env, options)` the declared and discovered one; `await registryLanguageModel(registry, env, ref, options)` is the adapter's model lookup.
 
 ```ts
 import { resolveRegistryLanguageModel } from '@skaile/forge-settings/ai-sdk'

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@skaile/forge-settings",
   "configKey": "forgeSettings",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/runtime/editor/index.d.ts

@@ -1,97 +1,23 @@
 /**
- * `@skaile/forge-settings/editor` — the editor's `models` port over a provider
- * registry.
+ * `@skaile/forge-settings/editor` - the former name of
+ * `@skaile/forge-settings/model-provider`, kept so 2.x hosts keep working.
  *
- * `@skaile/forge-editor`'s AI routes ask the host's `ModelProvider`
- * (`listModels` / `languageModel`) before their own runtime-config presets.
- * This adapter answers from the host's registry and is a thin layer over
- * `@skaile/forge-settings/ai-sdk`: a profile's id is the registry selector
- * `<providerId>/<modelId>`, which `languageModel` receives back as
- * `{ preset: id }` and resolves through the same constructor, credential
- * resolver and policy as every other registry model. Every `llm` entry whose
- * surface the AI SDK constructor speaks (`openai-completions`,
- * `openai-responses`, `anthropic-messages`) and that has an endpoint is
- * offered.
- *
- * Listing combines what the registry declares (`model_map` / `capabilities`)
- * with what an entry's own models list reports, for entries that declare
- * `discovery` or declare no models at all. Declared models work without a
- * models list; a declared identity wins over a discovered one.
- *
- * The registry is authoritative for the selectors it owns: an empty registry
- * lists `[]`, and a `<providerId>/…` selector naming a registry entry that is
- * disabled, refused or unresolvable throws instead of falling through to the
- * editor's presets. Only a selector the registry does not own answers `null`.
- *
- * The registry and the credential environment are supplied by the host on every
- * call, so provider edits apply without a restart and nothing reads the ambient
- * process. Failures are typed ({@link ModelResolutionError}); the host maps
- * them to HTTP in `onFailure`.
- *
- * `@skaile/forge-editor` is an optional peer of this entry only, for its
- * `ModelProvider` contract (types).
+ * Every export is the `/model-provider` one under its old name. New code
+ * imports `/model-provider`; this entry goes with the next major.
  */
-import type { ModelProfile, ModelRef } from "@skaile/forge-editor/ai";
-import type { ModelProvider } from "@skaile/forge-editor/server";
-import { type LanguageModelObject } from "@skaile/provider-registry/ai-sdk";
-import { ModelResolutionError } from "../model/errors.js";
-import { type CredentialPolicy } from "../server/credential-policy.js";
-import { type AIProviderRegistryView } from "../shared/provider-registry.js";
+import { createModelProvider, declaredModelProfiles, listModelProfiles, type ModelPolicyOptions, type ModelProviderOptions, registryLanguageModel } from "../model-provider/index.js";
 export type { ModelResolutionCode } from "../model/errors.js";
 export { ModelResolutionError } from "../model/errors.js";
-/** Policy and credential store for an editor model call; see `CredentialPolicy`. */
-export interface EditorModelPolicyOptions {
-    /** Which credential references may be resolved; refused entries are not offered. */
-    policy?: CredentialPolicy;
-    /** Local encrypted store for `keyring:` references; else `FORGE_CREDENTIAL_STORE` of the env. */
-    path?: string;
-    /** 64-char hex key of the local store; else `FORGE_CREDENTIAL_KEY` of the env. */
-    key?: string;
-}
-/**
- * The models the registry declares (`model_map` / `capabilities`) as editor
- * model profiles, in registry order — no network. With a policy, entries it
- * refuses are left out. {@link createEditorModelProvider} lists these plus the
- * models discovered live.
- */
-export declare function editorModelProfiles(registry: AIProviderRegistryView, options?: EditorModelPolicyOptions): ModelProfile[];
-/**
- * Declared and discovered models as editor profiles, in registry order, one
- * profile per selector.
- *
- * An entry's models list is asked when the entry declares `discovery` (and not
- * `type: none`) or declares no models; it is asked with the credential the
- * policy allows, exactly as inference resolves it. A failed or unsupported
- * list leaves that entry with its declared models. A discovered id that a
- * declared model already names (as selector or as mapped provider id) is
- * dropped: the declared identity wins.
- */
-export declare function listEditorModelProfiles(registry: AIProviderRegistryView, env: Record<string, string | undefined>, options?: EditorModelPolicyOptions): Promise<ModelProfile[]>;
-/**
- * The language model of selector `ref.preset`, or `null` when the registry does
- * not own it: a browser-defined `{ endpoint, model, apiKey }` reference, or a
- * preset id whose leading segment names no registry entry, is the editor's own
- * to resolve.
- *
- * Delegates to `resolveRegistryLanguageModel` (`@skaile/forge-settings/ai-sdk`),
- * so the selector's model id may be declared or discovered: an id the entry's
- * `model_map` maps is sent as the mapped id, any other is sent verbatim.
- *
- * @throws {ModelResolutionError} for an owned selector: `unknown_selector` when
- *   the entry is disabled or not an `llm` entry, `policy_refused` when the
- *   policy refuses it (checked before its credential is read), `unresolved`
- *   when its credential, endpoint or SDK does not resolve. No message carries a
- *   secret.
- */
-export declare function editorLanguageModel(registry: AIProviderRegistryView, env: Record<string, string | undefined>, ref: ModelRef, options?: EditorModelPolicyOptions): Promise<LanguageModelObject | null>;
-/** Options for {@link createEditorModelProvider}. */
-export interface EditorModelProviderOptions extends EditorModelPolicyOptions {
-    /** The registry to serve, read on every call. */
-    registry: () => AIProviderRegistryView | Promise<AIProviderRegistryView>;
-    /** The environment `env:` references resolve against, read on every call. */
-    env: () => Record<string, string | undefined> | Promise<Record<string, string | undefined>>;
-    /** Turn a typed failure into the host's own error (e.g. its HTTP error). Default: rethrow as is. */
-    onFailure?: (error: ModelResolutionError) => Error;
-}
-/** The editor's `models` port over the host's registry. */
-export declare function createEditorModelProvider(options: EditorModelProviderOptions): ModelProvider;
+export type { ModelProfile, ModelProvider, ModelRef } from "../model-provider/index.js";
+/** @deprecated Use `ModelPolicyOptions` from `@skaile/forge-settings/model-provider`. */
+export type EditorModelPolicyOptions = ModelPolicyOptions;
+/** @deprecated Use `ModelProviderOptions` from `@skaile/forge-settings/model-provider`. */
+export type EditorModelProviderOptions = ModelProviderOptions;
+/** @deprecated Use `declaredModelProfiles` from `@skaile/forge-settings/model-provider`. */
+export declare const editorModelProfiles: typeof declaredModelProfiles;
+/** @deprecated Use `listModelProfiles` from `@skaile/forge-settings/model-provider`. */
+export declare const listEditorModelProfiles: typeof listModelProfiles;
+/** @deprecated Use `registryLanguageModel` from `@skaile/forge-settings/model-provider`. */
+export declare const editorLanguageModel: typeof registryLanguageModel;
+/** @deprecated Use `createModelProvider` from `@skaile/forge-settings/model-provider`. */
+export declare const createEditorModelProvider: typeof createModelProvider;

package/dist/runtime/editor/index.js

@@ -1,114 +1,11 @@
-import { resolveEntryBaseUrl } from "@skaile/provider-registry";
-import { AI_SDK_SURFACES } from "@skaile/provider-registry/ai-sdk";
-import { resolveRegistryLanguageModel } from "../ai-sdk/index.js";
-import { ModelResolutionError } from "../model/errors.js";
-import { credentialStoreOptions, selectorProviderId } from "../model/selector.js";
-import { entryPolicyRefusal } from "../server/credential-policy.js";
-import { discoverProviderModels } from "../server/provider-discovery.js";
-import { listAIProviderModels } from "../server/provider-service.js";
 import {
-  asMergedRegistry,
-  entriesOfKind
-} from "../shared/provider-registry.js";
+  createModelProvider,
+  declaredModelProfiles,
+  listModelProfiles,
+  registryLanguageModel
+} from "../model-provider/index.js";
 export { ModelResolutionError } from "../model/errors.js";
-function editorEntries(registry, policy) {
-  const entries = /* @__PURE__ */ new Map();
-  for (const [id, entry] of entriesOfKind(registry, "llm")) {
-    const surface = entry.surface ?? "openai-completions";
-    if (!AI_SDK_SURFACES.includes(surface)) continue;
-    if (!resolveEntryBaseUrl(entry)) continue;
-    if (entryPolicyRefusal(entry, policy)) continue;
-    entries.set(id, entry);
-  }
-  return entries;
-}
-function registryProfile(providerId, entry, model) {
-  return {
-    id: model.id,
-    label: `${providerId} \xB7 ${model.name}`,
-    endpoint: resolveEntryBaseUrl(entry),
-    model: model.providerModelId,
-    source: "preset"
-  };
-}
-function declaredProfiles(registry, entries) {
-  const byProvider = /* @__PURE__ */ new Map();
-  for (const model of listAIProviderModels(registry)) {
-    const entry = entries.get(model.providerId);
-    if (!entry) continue;
-    const profile = registryProfile(model.providerId, entry, {
-      id: model.id,
-      name: model.modelId,
-      providerModelId: model.providerModelId
-    });
-    const own = byProvider.get(model.providerId);
-    if (own) own.push(profile);
-    else byProvider.set(model.providerId, [profile]);
-  }
-  return byProvider;
-}
-export function editorModelProfiles(registry, options = {}) {
-  return [...declaredProfiles(registry, editorEntries(registry, options.policy)).values()].flat();
-}
-export async function listEditorModelProfiles(registry, env, options = {}) {
-  const entries = editorEntries(registry, options.policy);
-  const declared = declaredProfiles(registry, entries);
-  const listed = await Promise.all(
-    [...entries].map(async ([providerId, entry]) => {
-      const own = declared.get(providerId) ?? [];
-      const listable = entry.discovery !== void 0 ? entry.discovery.type !== "none" : own.length === 0;
-      if (!listable) return own;
-      const result = await discoverProviderModels(
-        providerId,
-        registry,
-        credentialStoreOptions(env, options)
-      );
-      if (result.status !== "live") return own;
-      const taken = new Set(
-        own.flatMap((profile) => [profile.id, `${providerId}/${profile.model}`])
-      );
-      const discovered = result.models.flatMap((model) => {
-        const id = `${providerId}/${model.id}`;
-        if (taken.has(id)) return [];
-        taken.add(id);
-        return [
-          registryProfile(providerId, entry, { id, name: model.name, providerModelId: model.id })
-        ];
-      });
-      return [...own, ...discovered];
-    })
-  );
-  return listed.flat();
-}
-export async function editorLanguageModel(registry, env, ref, options = {}) {
-  if (!("preset" in ref)) return null;
-  const merged = asMergedRegistry(registry);
-  const head = selectorProviderId(ref.preset);
-  if (head === void 0 || merged.providers[head] === void 0) return null;
-  const resolved = await resolveRegistryLanguageModel(ref.preset, {
-    registry: merged,
-    ...credentialStoreOptions(env, options)
-  });
-  return resolved.model;
-}
-export function createEditorModelProvider(options) {
-  return {
-    async languageModel(ref) {
-      try {
-        return await editorLanguageModel(
-          await options.registry(),
-          await options.env(),
-          ref,
-          options
-        );
-      } catch (error) {
-        if (error instanceof ModelResolutionError && options.onFailure)
-          throw options.onFailure(error);
-        throw error;
-      }
-    },
-    async listModels() {
-      return listEditorModelProfiles(await options.registry(), await options.env(), options);
-    }
-  };
-}
+export const editorModelProfiles = declaredModelProfiles;
+export const listEditorModelProfiles = listModelProfiles;
+export const editorLanguageModel = registryLanguageModel;
+export const createEditorModelProvider = createModelProvider;

package/dist/runtime/model-provider/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * `@skaile/forge-settings/model-provider` — a model provider over a provider
+ * registry: the models a host offers (`listModels`) and the language model of
+ * a model reference (`languageModel`).
+ *
+ * Its shape is the one a host's model port expects (the editor's `models`
+ * port, a chat handler, an agent runtime): the types below are this entry's
+ * own and match such a port structurally, so the host assigns
+ * `createModelProvider(...)` to it and its typecheck verifies the fit.
+ *
+ * The adapter is a thin layer over `@skaile/forge-settings/ai-sdk`: a
+ * profile's id is the registry selector `<providerId>/<modelId>`, which
+ * `languageModel` receives back as `{ preset: id }` and resolves through the
+ * same constructor, credential resolver and policy as every other registry
+ * model. Every `llm` entry whose surface the AI SDK constructor speaks
+ * (`openai-completions`, `openai-responses`, `anthropic-messages`) and that has
+ * an endpoint is offered.
+ *
+ * Listing combines what the registry declares (`model_map` / `capabilities`)
+ * with what an entry's own models list reports, for entries that declare
+ * `discovery` or declare no models at all. Declared models work without a
+ * models list; a declared identity wins over a discovered one.
+ *
+ * The registry is authoritative for the selectors it owns: an empty registry
+ * lists `[]`, and a `<providerId>/…` selector naming a registry entry that is
+ * disabled, refused or unresolvable throws instead of falling through to the
+ * host's own models. Only a selector the registry does not own answers `null`.
+ *
+ * The registry and the credential environment are supplied by the host on every
+ * call, so provider edits apply without a restart and nothing reads the ambient
+ * process. Failures are typed ({@link ModelResolutionError}); the host maps
+ * them to HTTP in `onFailure`.
+ */
+import { type LanguageModelObject } from "@skaile/provider-registry/ai-sdk";
+import { ModelResolutionError } from "../model/errors.js";
+import { type CredentialPolicy } from "../server/credential-policy.js";
+import { type AIProviderRegistryView } from "../shared/provider-registry.js";
+export type { ModelResolutionCode } from "../model/errors.js";
+export { ModelResolutionError } from "../model/errors.js";
+/** A model as a host offers it; `id` is what `languageModel` receives back as `{ preset: id }`. Never carries a key. */
+export interface ModelProfile {
+    id: string;
+    label: string;
+    endpoint: string;
+    model: string;
+    source: "preset" | "user";
+}
+/** The model a request runs on: a preset (registry selector) by id, or an OpenAI-compatible endpoint with its own key. */
+export type ModelRef = {
+    preset: string;
+} | {
+    endpoint: string;
+    model: string;
+    apiKey: string;
+};
+/** The provider {@link createModelProvider} returns. */
+export interface ModelProvider {
+    /** The language model of `ref`; `null` when the registry does not own it. */
+    languageModel(ref: ModelRef): Promise<LanguageModelObject | null>;
+    /** The registry's declared and discovered models as profiles. */
+    listModels(): Promise<ModelProfile[]>;
+}
+/** Policy and credential store for a model call; see `CredentialPolicy`. */
+export interface ModelPolicyOptions {
+    /** Which credential references may be resolved; refused entries are not offered. */
+    policy?: CredentialPolicy;
+    /** Local encrypted store for `keyring:` references; else `FORGE_CREDENTIAL_STORE` of the env. */
+    path?: string;
+    /** 64-char hex key of the local store; else `FORGE_CREDENTIAL_KEY` of the env. */
+    key?: string;
+}
+/**
+ * The models the registry declares (`model_map` / `capabilities`) as model
+ * profiles, in registry order — no network. With a policy, entries it
+ * refuses are left out. {@link createModelProvider} lists these plus the
+ * models discovered live.
+ */
+export declare function declaredModelProfiles(registry: AIProviderRegistryView, options?: ModelPolicyOptions): ModelProfile[];
+/**
+ * Declared and discovered models as profiles, in registry order, one
+ * profile per selector.
+ *
+ * An entry's models list is asked when the entry declares `discovery` (and not
+ * `type: none`) or declares no models; it is asked with the credential the
+ * policy allows, exactly as inference resolves it. A failed or unsupported
+ * list leaves that entry with its declared models. A discovered id that a
+ * declared model already names (as selector or as mapped provider id) is
+ * dropped: the declared identity wins.
+ */
+export declare function listModelProfiles(registry: AIProviderRegistryView, env: Record<string, string | undefined>, options?: ModelPolicyOptions): Promise<ModelProfile[]>;
+/**
+ * The language model of selector `ref.preset`, or `null` when the registry does
+ * not own it: a browser-defined `{ endpoint, model, apiKey }` reference, or a
+ * preset id whose leading segment names no registry entry, is the host's own
+ * to resolve.
+ *
+ * Delegates to `resolveRegistryLanguageModel` (`@skaile/forge-settings/ai-sdk`),
+ * so the selector's model id may be declared or discovered: an id the entry's
+ * `model_map` maps is sent as the mapped id, any other is sent verbatim.
+ *
+ * @throws {ModelResolutionError} for an owned selector: `unknown_selector` when
+ *   the entry is disabled or not an `llm` entry, `policy_refused` when the
+ *   policy refuses it (checked before its credential is read), `unresolved`
+ *   when its credential, endpoint or SDK does not resolve. No message carries a
+ *   secret.
+ */
+export declare function registryLanguageModel(registry: AIProviderRegistryView, env: Record<string, string | undefined>, ref: ModelRef, options?: ModelPolicyOptions): Promise<LanguageModelObject | null>;
+/** Options for {@link createModelProvider}. */
+export interface ModelProviderOptions extends ModelPolicyOptions {
+    /** The registry to serve, read on every call. */
+    registry: () => AIProviderRegistryView | Promise<AIProviderRegistryView>;
+    /** The environment `env:` references resolve against, read on every call. */
+    env: () => Record<string, string | undefined> | Promise<Record<string, string | undefined>>;
+    /** Turn a typed failure into the host's own error (e.g. its HTTP error). Default: rethrow as is. */
+    onFailure?: (error: ModelResolutionError) => Error;
+}
+/** A model provider over the host's registry, for a host's model port (e.g. the editor's `models`). */
+export declare function createModelProvider(options: ModelProviderOptions): ModelProvider;

package/dist/runtime/model-provider/index.js

@@ -0,0 +1,114 @@
+import { resolveEntryBaseUrl } from "@skaile/provider-registry";
+import { AI_SDK_SURFACES } from "@skaile/provider-registry/ai-sdk";
+import { resolveRegistryLanguageModel } from "../ai-sdk/index.js";
+import { ModelResolutionError } from "../model/errors.js";
+import { credentialStoreOptions, selectorProviderId } from "../model/selector.js";
+import { entryPolicyRefusal } from "../server/credential-policy.js";
+import { discoverProviderModels } from "../server/provider-discovery.js";
+import { listAIProviderModels } from "../server/provider-service.js";
+import {
+  asMergedRegistry,
+  entriesOfKind
+} from "../shared/provider-registry.js";
+export { ModelResolutionError } from "../model/errors.js";
+function servedEntries(registry, policy) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [id, entry] of entriesOfKind(registry, "llm")) {
+    const surface = entry.surface ?? "openai-completions";
+    if (!AI_SDK_SURFACES.includes(surface)) continue;
+    if (!resolveEntryBaseUrl(entry)) continue;
+    if (entryPolicyRefusal(entry, policy)) continue;
+    entries.set(id, entry);
+  }
+  return entries;
+}
+function registryProfile(providerId, entry, model) {
+  return {
+    id: model.id,
+    label: `${providerId} \xB7 ${model.name}`,
+    endpoint: resolveEntryBaseUrl(entry),
+    model: model.providerModelId,
+    source: "preset"
+  };
+}
+function declaredProfiles(registry, entries) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const model of listAIProviderModels(registry)) {
+    const entry = entries.get(model.providerId);
+    if (!entry) continue;
+    const profile = registryProfile(model.providerId, entry, {
+      id: model.id,
+      name: model.modelId,
+      providerModelId: model.providerModelId
+    });
+    const own = byProvider.get(model.providerId);
+    if (own) own.push(profile);
+    else byProvider.set(model.providerId, [profile]);
+  }
+  return byProvider;
+}
+export function declaredModelProfiles(registry, options = {}) {
+  return [...declaredProfiles(registry, servedEntries(registry, options.policy)).values()].flat();
+}
+export async function listModelProfiles(registry, env, options = {}) {
+  const entries = servedEntries(registry, options.policy);
+  const declared = declaredProfiles(registry, entries);
+  const listed = await Promise.all(
+    [...entries].map(async ([providerId, entry]) => {
+      const own = declared.get(providerId) ?? [];
+      const listable = entry.discovery !== void 0 ? entry.discovery.type !== "none" : own.length === 0;
+      if (!listable) return own;
+      const result = await discoverProviderModels(
+        providerId,
+        registry,
+        credentialStoreOptions(env, options)
+      );
+      if (result.status !== "live") return own;
+      const taken = new Set(
+        own.flatMap((profile) => [profile.id, `${providerId}/${profile.model}`])
+      );
+      const discovered = result.models.flatMap((model) => {
+        const id = `${providerId}/${model.id}`;
+        if (taken.has(id)) return [];
+        taken.add(id);
+        return [
+          registryProfile(providerId, entry, { id, name: model.name, providerModelId: model.id })
+        ];
+      });
+      return [...own, ...discovered];
+    })
+  );
+  return listed.flat();
+}
+export async function registryLanguageModel(registry, env, ref, options = {}) {
+  if (!("preset" in ref)) return null;
+  const merged = asMergedRegistry(registry);
+  const head = selectorProviderId(ref.preset);
+  if (head === void 0 || merged.providers[head] === void 0) return null;
+  const resolved = await resolveRegistryLanguageModel(ref.preset, {
+    registry: merged,
+    ...credentialStoreOptions(env, options)
+  });
+  return resolved.model;
+}
+export function createModelProvider(options) {
+  return {
+    async languageModel(ref) {
+      try {
+        return await registryLanguageModel(
+          await options.registry(),
+          await options.env(),
+          ref,
+          options
+        );
+      } catch (error) {
+        if (error instanceof ModelResolutionError && options.onFailure)
+          throw options.onFailure(error);
+        throw error;
+      }
+    },
+    async listModels() {
+      return listModelProfiles(await options.registry(), await options.env(), options);
+    }
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@skaile/forge-settings",
-  "version": "2.0.2",
-  "description": "Provider and settings operations for Skaile forge apps: provider registry layers, credential store, env layers, model discovery, the providers panel, and editor / AI SDK model adapters.",
+  "version": "2.1.0",
+  "description": "Provider and settings operations for Skaile forge apps: provider registry layers, credential store, env layers, model discovery, the providers panel, and model provider / AI SDK model adapters.",
   "type": "module",
   "main": "./dist/module.mjs",
   "types": "./dist/types.d.mts",
@@ -22,6 +22,10 @@
       "types": "./dist/runtime/ai-sdk/index.d.ts",
       "import": "./dist/runtime/ai-sdk/index.js"
     },
+    "./model-provider": {
+      "types": "./dist/runtime/model-provider/index.d.ts",
+      "import": "./dist/runtime/model-provider/index.js"
+    },
     "./editor": {
       "types": "./dist/runtime/editor/index.d.ts",
       "import": "./dist/runtime/editor/index.js"
@@ -68,7 +72,6 @@
     "@ai-sdk/openai": "^4.0.0",
     "@ai-sdk/openai-compatible": "^3.0.0",
     "@nuxt/ui": "^4.11.1",
-    "@skaile/forge-editor": "^8.0.0",
     "@skaile/workspaces": "^7.8.0 || ^8.0.0 || ^9.0.0 || ^10.0.0",
     "ai": "^7.0.0",
     "nuxt": "^4.0.0",
@@ -87,9 +90,6 @@
     "@nuxt/ui": {
       "optional": true
     },
-    "@skaile/forge-editor": {
-      "optional": true
-    },
     "@skaile/workspaces": {
       "optional": true
     },
@@ -109,7 +109,6 @@
     "@nuxt/module-builder": "^1.0.0",
     "@nuxt/schema": "^4.0.0",
     "@nuxt/ui": "^4.11.1",
-    "@skaile/forge-editor": "^8.0.0",
     "@skaile/workspaces": "^10.3.0",
     "@types/bun": "^1.2.0",
     "@types/node": "^22.0.0",

package/src/runtime/editor/index.ts

@@ -1,241 +1,32 @@
 /**
- * `@skaile/forge-settings/editor` — the editor's `models` port over a provider
- * registry.
+ * `@skaile/forge-settings/editor` - the former name of
+ * `@skaile/forge-settings/model-provider`, kept so 2.x hosts keep working.
  *
- * `@skaile/forge-editor`'s AI routes ask the host's `ModelProvider`
- * (`listModels` / `languageModel`) before their own runtime-config presets.
- * This adapter answers from the host's registry and is a thin layer over
- * `@skaile/forge-settings/ai-sdk`: a profile's id is the registry selector
- * `<providerId>/<modelId>`, which `languageModel` receives back as
- * `{ preset: id }` and resolves through the same constructor, credential
- * resolver and policy as every other registry model. Every `llm` entry whose
- * surface the AI SDK constructor speaks (`openai-completions`,
- * `openai-responses`, `anthropic-messages`) and that has an endpoint is
- * offered.
- *
- * Listing combines what the registry declares (`model_map` / `capabilities`)
- * with what an entry's own models list reports, for entries that declare
- * `discovery` or declare no models at all. Declared models work without a
- * models list; a declared identity wins over a discovered one.
- *
- * The registry is authoritative for the selectors it owns: an empty registry
- * lists `[]`, and a `<providerId>/…` selector naming a registry entry that is
- * disabled, refused or unresolvable throws instead of falling through to the
- * editor's presets. Only a selector the registry does not own answers `null`.
- *
- * The registry and the credential environment are supplied by the host on every
- * call, so provider edits apply without a restart and nothing reads the ambient
- * process. Failures are typed ({@link ModelResolutionError}); the host maps
- * them to HTTP in `onFailure`.
- *
- * `@skaile/forge-editor` is an optional peer of this entry only, for its
- * `ModelProvider` contract (types).
+ * Every export is the `/model-provider` one under its old name. New code
+ * imports `/model-provider`; this entry goes with the next major.
  */
-
-import type { ModelProfile, ModelRef } from "@skaile/forge-editor/ai";
-import type { ModelProvider } from "@skaile/forge-editor/server";
-import { resolveEntryBaseUrl } from "@skaile/provider-registry";
-import { AI_SDK_SURFACES, type LanguageModelObject } from "@skaile/provider-registry/ai-sdk";
-import { resolveRegistryLanguageModel } from "../ai-sdk";
-import { ModelResolutionError } from "../model/errors";
-import { credentialStoreOptions, selectorProviderId } from "../model/selector";
-import { type CredentialPolicy, entryPolicyRefusal } from "../server/credential-policy";
-import { discoverProviderModels } from "../server/provider-discovery";
-import { listAIProviderModels } from "../server/provider-service";
 import {
-  type AIProviderLlmEntry,
-  type AIProviderRegistryView,
-  asMergedRegistry,
-  entriesOfKind,
-} from "../shared/provider-registry";
+  createModelProvider,
+  declaredModelProfiles,
+  listModelProfiles,
+  type ModelPolicyOptions,
+  type ModelProviderOptions,
+  registryLanguageModel,
+} from "../model-provider";
 
 export type { ModelResolutionCode } from "../model/errors";
 export { ModelResolutionError } from "../model/errors";
-
-/** Policy and credential store for an editor model call; see `CredentialPolicy`. */
-export interface EditorModelPolicyOptions {
-  /** Which credential references may be resolved; refused entries are not offered. */
-  policy?: CredentialPolicy;
-  /** Local encrypted store for `keyring:` references; else `FORGE_CREDENTIAL_STORE` of the env. */
-  path?: string;
-  /** 64-char hex key of the local store; else `FORGE_CREDENTIAL_KEY` of the env. */
-  key?: string;
-}
-
-/** The entries the AI SDK constructor can serve (surface and endpoint), by id; policy-refused ones left out. */
-function editorEntries(
-  registry: AIProviderRegistryView,
-  policy: CredentialPolicy | undefined,
-): Map<string, AIProviderLlmEntry> {
-  const entries = new Map<string, AIProviderLlmEntry>();
-  for (const [id, entry] of entriesOfKind(registry, "llm")) {
-    const surface = entry.surface ?? "openai-completions";
-    if (!(AI_SDK_SURFACES as readonly string[]).includes(surface)) continue;
-    if (!resolveEntryBaseUrl(entry)) continue;
-    if (entryPolicyRefusal(entry, policy)) continue;
-    entries.set(id, entry);
-  }
-  return entries;
-}
-
-/** One registry model as an editor profile: its selector `id`, shown as `<providerId> · <name>`. */
-function registryProfile(
-  providerId: string,
-  entry: AIProviderLlmEntry,
-  model: { id: string; name: string; providerModelId: string },
-): ModelProfile {
-  return {
-    id: model.id,
-    label: `${providerId} · ${model.name}`,
-    endpoint: resolveEntryBaseUrl(entry)!,
-    model: model.providerModelId,
-    source: "preset",
-  };
-}
-
-/** The declared models of the served `entries` as profiles, grouped by provider id in registry order. */
-function declaredProfiles(
-  registry: AIProviderRegistryView,
-  entries: Map<string, AIProviderLlmEntry>,
-): Map<string, ModelProfile[]> {
-  const byProvider = new Map<string, ModelProfile[]>();
-  for (const model of listAIProviderModels(registry)) {
-    const entry = entries.get(model.providerId);
-    if (!entry) continue;
-    const profile = registryProfile(model.providerId, entry, {
-      id: model.id,
-      name: model.modelId,
-      providerModelId: model.providerModelId,
-    });
-    const own = byProvider.get(model.providerId);
-    if (own) own.push(profile);
-    else byProvider.set(model.providerId, [profile]);
-  }
-  return byProvider;
-}
-
-/**
- * The models the registry declares (`model_map` / `capabilities`) as editor
- * model profiles, in registry order — no network. With a policy, entries it
- * refuses are left out. {@link createEditorModelProvider} lists these plus the
- * models discovered live.
- */
-export function editorModelProfiles(
-  registry: AIProviderRegistryView,
-  options: EditorModelPolicyOptions = {},
-): ModelProfile[] {
-  return [...declaredProfiles(registry, editorEntries(registry, options.policy)).values()].flat();
-}
-
-/**
- * Declared and discovered models as editor profiles, in registry order, one
- * profile per selector.
- *
- * An entry's models list is asked when the entry declares `discovery` (and not
- * `type: none`) or declares no models; it is asked with the credential the
- * policy allows, exactly as inference resolves it. A failed or unsupported
- * list leaves that entry with its declared models. A discovered id that a
- * declared model already names (as selector or as mapped provider id) is
- * dropped: the declared identity wins.
- */
-export async function listEditorModelProfiles(
-  registry: AIProviderRegistryView,
-  env: Record<string, string | undefined>,
-  options: EditorModelPolicyOptions = {},
-): Promise<ModelProfile[]> {
-  const entries = editorEntries(registry, options.policy);
-  const declared = declaredProfiles(registry, entries);
-  const listed = await Promise.all(
-    [...entries].map(async ([providerId, entry]): Promise<ModelProfile[]> => {
-      const own = declared.get(providerId) ?? [];
-      const listable =
-        entry.discovery !== undefined ? entry.discovery.type !== "none" : own.length === 0;
-      if (!listable) return own;
-      const result = await discoverProviderModels(
-        providerId,
-        registry,
-        credentialStoreOptions(env, options),
-      );
-      if (result.status !== "live") return own;
-      const taken = new Set(
-        own.flatMap((profile) => [profile.id, `${providerId}/${profile.model}`]),
-      );
-      const discovered = result.models.flatMap((model) => {
-        const id = `${providerId}/${model.id}`;
-        if (taken.has(id)) return [];
-        taken.add(id);
-        return [
-          registryProfile(providerId, entry, { id, name: model.name, providerModelId: model.id }),
-        ];
-      });
-      return [...own, ...discovered];
-    }),
-  );
-  return listed.flat();
-}
-
-/**
- * The language model of selector `ref.preset`, or `null` when the registry does
- * not own it: a browser-defined `{ endpoint, model, apiKey }` reference, or a
- * preset id whose leading segment names no registry entry, is the editor's own
- * to resolve.
- *
- * Delegates to `resolveRegistryLanguageModel` (`@skaile/forge-settings/ai-sdk`),
- * so the selector's model id may be declared or discovered: an id the entry's
- * `model_map` maps is sent as the mapped id, any other is sent verbatim.
- *
- * @throws {ModelResolutionError} for an owned selector: `unknown_selector` when
- *   the entry is disabled or not an `llm` entry, `policy_refused` when the
- *   policy refuses it (checked before its credential is read), `unresolved`
- *   when its credential, endpoint or SDK does not resolve. No message carries a
- *   secret.
- */
-export async function editorLanguageModel(
-  registry: AIProviderRegistryView,
-  env: Record<string, string | undefined>,
-  ref: ModelRef,
-  options: EditorModelPolicyOptions = {},
-): Promise<LanguageModelObject | null> {
-  if (!("preset" in ref)) return null;
-  const merged = asMergedRegistry(registry);
-  const head = selectorProviderId(ref.preset);
-  if (head === undefined || merged.providers[head] === undefined) return null;
-  const resolved = await resolveRegistryLanguageModel(ref.preset, {
-    registry: merged,
-    ...credentialStoreOptions(env, options),
-  });
-  return resolved.model;
-}
-
-/** Options for {@link createEditorModelProvider}. */
-export interface EditorModelProviderOptions extends EditorModelPolicyOptions {
-  /** The registry to serve, read on every call. */
-  registry: () => AIProviderRegistryView | Promise<AIProviderRegistryView>;
-  /** The environment `env:` references resolve against, read on every call. */
-  env: () => Record<string, string | undefined> | Promise<Record<string, string | undefined>>;
-  /** Turn a typed failure into the host's own error (e.g. its HTTP error). Default: rethrow as is. */
-  onFailure?: (error: ModelResolutionError) => Error;
-}
-
-/** The editor's `models` port over the host's registry. */
-export function createEditorModelProvider(options: EditorModelProviderOptions): ModelProvider {
-  return {
-    async languageModel(ref) {
-      try {
-        return await editorLanguageModel(
-          await options.registry(),
-          await options.env(),
-          ref,
-          options,
-        );
-      } catch (error) {
-        if (error instanceof ModelResolutionError && options.onFailure)
-          throw options.onFailure(error);
-        throw error;
-      }
-    },
-    async listModels() {
-      return listEditorModelProfiles(await options.registry(), await options.env(), options);
-    },
-  };
-}
+export type { ModelProfile, ModelProvider, ModelRef } from "../model-provider";
+
+/** @deprecated Use `ModelPolicyOptions` from `@skaile/forge-settings/model-provider`. */
+export type EditorModelPolicyOptions = ModelPolicyOptions;
+/** @deprecated Use `ModelProviderOptions` from `@skaile/forge-settings/model-provider`. */
+export type EditorModelProviderOptions = ModelProviderOptions;
+/** @deprecated Use `declaredModelProfiles` from `@skaile/forge-settings/model-provider`. */
+export const editorModelProfiles = declaredModelProfiles;
+/** @deprecated Use `listModelProfiles` from `@skaile/forge-settings/model-provider`. */
+export const listEditorModelProfiles = listModelProfiles;
+/** @deprecated Use `registryLanguageModel` from `@skaile/forge-settings/model-provider`. */
+export const editorLanguageModel = registryLanguageModel;
+/** @deprecated Use `createModelProvider` from `@skaile/forge-settings/model-provider`. */
+export const createEditorModelProvider = createModelProvider;

package/src/runtime/model-provider/index.ts

@@ -0,0 +1,259 @@
+/**
+ * `@skaile/forge-settings/model-provider` — a model provider over a provider
+ * registry: the models a host offers (`listModels`) and the language model of
+ * a model reference (`languageModel`).
+ *
+ * Its shape is the one a host's model port expects (the editor's `models`
+ * port, a chat handler, an agent runtime): the types below are this entry's
+ * own and match such a port structurally, so the host assigns
+ * `createModelProvider(...)` to it and its typecheck verifies the fit.
+ *
+ * The adapter is a thin layer over `@skaile/forge-settings/ai-sdk`: a
+ * profile's id is the registry selector `<providerId>/<modelId>`, which
+ * `languageModel` receives back as `{ preset: id }` and resolves through the
+ * same constructor, credential resolver and policy as every other registry
+ * model. Every `llm` entry whose surface the AI SDK constructor speaks
+ * (`openai-completions`, `openai-responses`, `anthropic-messages`) and that has
+ * an endpoint is offered.
+ *
+ * Listing combines what the registry declares (`model_map` / `capabilities`)
+ * with what an entry's own models list reports, for entries that declare
+ * `discovery` or declare no models at all. Declared models work without a
+ * models list; a declared identity wins over a discovered one.
+ *
+ * The registry is authoritative for the selectors it owns: an empty registry
+ * lists `[]`, and a `<providerId>/…` selector naming a registry entry that is
+ * disabled, refused or unresolvable throws instead of falling through to the
+ * host's own models. Only a selector the registry does not own answers `null`.
+ *
+ * The registry and the credential environment are supplied by the host on every
+ * call, so provider edits apply without a restart and nothing reads the ambient
+ * process. Failures are typed ({@link ModelResolutionError}); the host maps
+ * them to HTTP in `onFailure`.
+ */
+
+import { resolveEntryBaseUrl } from "@skaile/provider-registry";
+import { AI_SDK_SURFACES, type LanguageModelObject } from "@skaile/provider-registry/ai-sdk";
+import { resolveRegistryLanguageModel } from "../ai-sdk";
+import { ModelResolutionError } from "../model/errors";
+import { credentialStoreOptions, selectorProviderId } from "../model/selector";
+import { type CredentialPolicy, entryPolicyRefusal } from "../server/credential-policy";
+import { discoverProviderModels } from "../server/provider-discovery";
+import { listAIProviderModels } from "../server/provider-service";
+import {
+  type AIProviderLlmEntry,
+  type AIProviderRegistryView,
+  asMergedRegistry,
+  entriesOfKind,
+} from "../shared/provider-registry";
+
+export type { ModelResolutionCode } from "../model/errors";
+export { ModelResolutionError } from "../model/errors";
+
+/** A model as a host offers it; `id` is what `languageModel` receives back as `{ preset: id }`. Never carries a key. */
+export interface ModelProfile {
+  id: string;
+  label: string;
+  endpoint: string;
+  model: string;
+  source: "preset" | "user";
+}
+
+/** The model a request runs on: a preset (registry selector) by id, or an OpenAI-compatible endpoint with its own key. */
+export type ModelRef = { preset: string } | { endpoint: string; model: string; apiKey: string };
+
+/** The provider {@link createModelProvider} returns. */
+export interface ModelProvider {
+  /** The language model of `ref`; `null` when the registry does not own it. */
+  languageModel(ref: ModelRef): Promise<LanguageModelObject | null>;
+  /** The registry's declared and discovered models as profiles. */
+  listModels(): Promise<ModelProfile[]>;
+}
+
+/** Policy and credential store for a model call; see `CredentialPolicy`. */
+export interface ModelPolicyOptions {
+  /** Which credential references may be resolved; refused entries are not offered. */
+  policy?: CredentialPolicy;
+  /** Local encrypted store for `keyring:` references; else `FORGE_CREDENTIAL_STORE` of the env. */
+  path?: string;
+  /** 64-char hex key of the local store; else `FORGE_CREDENTIAL_KEY` of the env. */
+  key?: string;
+}
+
+/** The entries the AI SDK constructor can serve (surface and endpoint), by id; policy-refused ones left out. */
+function servedEntries(
+  registry: AIProviderRegistryView,
+  policy: CredentialPolicy | undefined,
+): Map<string, AIProviderLlmEntry> {
+  const entries = new Map<string, AIProviderLlmEntry>();
+  for (const [id, entry] of entriesOfKind(registry, "llm")) {
+    const surface = entry.surface ?? "openai-completions";
+    if (!(AI_SDK_SURFACES as readonly string[]).includes(surface)) continue;
+    if (!resolveEntryBaseUrl(entry)) continue;
+    if (entryPolicyRefusal(entry, policy)) continue;
+    entries.set(id, entry);
+  }
+  return entries;
+}
+
+/** One registry model as a profile: its selector `id`, shown as `<providerId> · <name>`. */
+function registryProfile(
+  providerId: string,
+  entry: AIProviderLlmEntry,
+  model: { id: string; name: string; providerModelId: string },
+): ModelProfile {
+  return {
+    id: model.id,
+    label: `${providerId} · ${model.name}`,
+    endpoint: resolveEntryBaseUrl(entry)!,
+    model: model.providerModelId,
+    source: "preset",
+  };
+}
+
+/** The declared models of the served `entries` as profiles, grouped by provider id in registry order. */
+function declaredProfiles(
+  registry: AIProviderRegistryView,
+  entries: Map<string, AIProviderLlmEntry>,
+): Map<string, ModelProfile[]> {
+  const byProvider = new Map<string, ModelProfile[]>();
+  for (const model of listAIProviderModels(registry)) {
+    const entry = entries.get(model.providerId);
+    if (!entry) continue;
+    const profile = registryProfile(model.providerId, entry, {
+      id: model.id,
+      name: model.modelId,
+      providerModelId: model.providerModelId,
+    });
+    const own = byProvider.get(model.providerId);
+    if (own) own.push(profile);
+    else byProvider.set(model.providerId, [profile]);
+  }
+  return byProvider;
+}
+
+/**
+ * The models the registry declares (`model_map` / `capabilities`) as model
+ * profiles, in registry order — no network. With a policy, entries it
+ * refuses are left out. {@link createModelProvider} lists these plus the
+ * models discovered live.
+ */
+export function declaredModelProfiles(
+  registry: AIProviderRegistryView,
+  options: ModelPolicyOptions = {},
+): ModelProfile[] {
+  return [...declaredProfiles(registry, servedEntries(registry, options.policy)).values()].flat();
+}
+
+/**
+ * Declared and discovered models as profiles, in registry order, one
+ * profile per selector.
+ *
+ * An entry's models list is asked when the entry declares `discovery` (and not
+ * `type: none`) or declares no models; it is asked with the credential the
+ * policy allows, exactly as inference resolves it. A failed or unsupported
+ * list leaves that entry with its declared models. A discovered id that a
+ * declared model already names (as selector or as mapped provider id) is
+ * dropped: the declared identity wins.
+ */
+export async function listModelProfiles(
+  registry: AIProviderRegistryView,
+  env: Record<string, string | undefined>,
+  options: ModelPolicyOptions = {},
+): Promise<ModelProfile[]> {
+  const entries = servedEntries(registry, options.policy);
+  const declared = declaredProfiles(registry, entries);
+  const listed = await Promise.all(
+    [...entries].map(async ([providerId, entry]): Promise<ModelProfile[]> => {
+      const own = declared.get(providerId) ?? [];
+      const listable =
+        entry.discovery !== undefined ? entry.discovery.type !== "none" : own.length === 0;
+      if (!listable) return own;
+      const result = await discoverProviderModels(
+        providerId,
+        registry,
+        credentialStoreOptions(env, options),
+      );
+      if (result.status !== "live") return own;
+      const taken = new Set(
+        own.flatMap((profile) => [profile.id, `${providerId}/${profile.model}`]),
+      );
+      const discovered = result.models.flatMap((model) => {
+        const id = `${providerId}/${model.id}`;
+        if (taken.has(id)) return [];
+        taken.add(id);
+        return [
+          registryProfile(providerId, entry, { id, name: model.name, providerModelId: model.id }),
+        ];
+      });
+      return [...own, ...discovered];
+    }),
+  );
+  return listed.flat();
+}
+
+/**
+ * The language model of selector `ref.preset`, or `null` when the registry does
+ * not own it: a browser-defined `{ endpoint, model, apiKey }` reference, or a
+ * preset id whose leading segment names no registry entry, is the host's own
+ * to resolve.
+ *
+ * Delegates to `resolveRegistryLanguageModel` (`@skaile/forge-settings/ai-sdk`),
+ * so the selector's model id may be declared or discovered: an id the entry's
+ * `model_map` maps is sent as the mapped id, any other is sent verbatim.
+ *
+ * @throws {ModelResolutionError} for an owned selector: `unknown_selector` when
+ *   the entry is disabled or not an `llm` entry, `policy_refused` when the
+ *   policy refuses it (checked before its credential is read), `unresolved`
+ *   when its credential, endpoint or SDK does not resolve. No message carries a
+ *   secret.
+ */
+export async function registryLanguageModel(
+  registry: AIProviderRegistryView,
+  env: Record<string, string | undefined>,
+  ref: ModelRef,
+  options: ModelPolicyOptions = {},
+): Promise<LanguageModelObject | null> {
+  if (!("preset" in ref)) return null;
+  const merged = asMergedRegistry(registry);
+  const head = selectorProviderId(ref.preset);
+  if (head === undefined || merged.providers[head] === undefined) return null;
+  const resolved = await resolveRegistryLanguageModel(ref.preset, {
+    registry: merged,
+    ...credentialStoreOptions(env, options),
+  });
+  return resolved.model;
+}
+
+/** Options for {@link createModelProvider}. */
+export interface ModelProviderOptions extends ModelPolicyOptions {
+  /** The registry to serve, read on every call. */
+  registry: () => AIProviderRegistryView | Promise<AIProviderRegistryView>;
+  /** The environment `env:` references resolve against, read on every call. */
+  env: () => Record<string, string | undefined> | Promise<Record<string, string | undefined>>;
+  /** Turn a typed failure into the host's own error (e.g. its HTTP error). Default: rethrow as is. */
+  onFailure?: (error: ModelResolutionError) => Error;
+}
+
+/** A model provider over the host's registry, for a host's model port (e.g. the editor's `models`). */
+export function createModelProvider(options: ModelProviderOptions): ModelProvider {
+  return {
+    async languageModel(ref) {
+      try {
+        return await registryLanguageModel(
+          await options.registry(),
+          await options.env(),
+          ref,
+          options,
+        );
+      } catch (error) {
+        if (error instanceof ModelResolutionError && options.onFailure)
+          throw options.onFailure(error);
+        throw error;
+      }
+    },
+    async listModels() {
+      return listModelProfiles(await options.registry(), await options.env(), options);
+    },
+  };
+}