@plurnk/plurnk-providers 1.3.5 → 1.3.6

package/src/index.ts

@@ -3,7 +3,7 @@ export type {
     FinishReason,
     Provider,
     ProviderAssistant,
-    ProviderFactory,
+    AiSdkProviderPlugin,
     ProviderOptions,
     ProviderResponse,
     ProviderUsage,
@@ -23,28 +23,24 @@ export {
     resetDiscoveryCache,
 } from "./ProviderRegistry.ts";
 
-// Scope-agnostic tier-2 discovery (SPEC §5) — exported so a consumer can list
-// installed providers (first-party + third-party) without instantiating them.
+// Scope-agnostic plugin discovery (SPEC §5).
 export { discover } from "./discover.ts";
 export type { DiscoverOptions, Discovery } from "./discover.ts";
 
-// Shared OpenAI-compatible transport machinery — the spine every sibling
-// extends and the basis for ./standardProviders.ts.
-export { default as OpenAICompatProvider, effortFromBudget } from "./OpenAICompat.ts";
-export type { OpenAICompatConfig, ReasoningStyle, GrammarStyle } from "./OpenAICompat.ts";
+// Stable PLURNK adapter over AI SDK language models and compatible local URLs.
+export { default as AiSdkProvider, effortFromBudget } from "./AiSdkProvider.ts";
+export type { AiSdkProviderConfig, ReasoningStyle, GrammarStyle } from "./AiSdkProvider.ts";
 // Capacity pool (SPEC §15): front N interchangeable backends as one Provider -
 // worker-sticky for KV-cache reuse, overflow to a healthy sibling; the blend
 // DECISION stays the consumer's, by choosing which pool to call.
 export { default as Pool } from "./Pool.ts";
-export { chatCompletionStream, chatCompletion, OpenAiHttpError, StreamIdleError } from "./openaiStream.ts";
-export type { StreamResponse, EncryptedReasoningItem, ProviderFetch } from "./openaiStream.ts";
+export type { ProviderFetch } from "./AiSdkProvider.ts";
 export { parseRequiredInt, parseOptionalInt, parseRequiredFloat, parseOptionalFloat, requireEnv, reasoningFromEnv, scopeEnvToAlias, dataCaptureFromEnv, contextWindowFromEnv, envelopeFromEnv, resolveReserve } from "./env.ts";
 export type { Reasoning, ReasoningMode, ReserveSpec } from "./env.ts";
 export { normalizeUsage, calculateCostUsd } from "./usage.ts";
 export type { RawUsage, TokenRates } from "./usage.ts";
 export { ProviderError, classifyProviderError, toProviderError, providerSource } from "./telemetry.ts";
 export type { TelemetryEvent, ProviderTelemetryKind } from "./telemetry.ts";
-export { STANDARD_PROVIDERS, isStandardProvider, standardProviderFromEnv } from "./standardProviders.ts";
 
 export { default as Mock } from "./Mock.ts";
 export type { MockAssistant, MockResponse, MockReturnedAssistant } from "./Mock.ts";

package/src/ollama.ts

@@ -0,0 +1,63 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { contextWindowFromEnv, parseRequiredInt, requireEnv } from "./env.ts";
+import { providerFromSdkModel } from "./catalogProvider.ts";
+import type { Provider, ProviderOptions } from "./types.ts";
+
+type ShowResponse = {
+    model_info?: Record<string, unknown>;
+};
+
+const fetchContextWindow = async ({
+    baseUrl,
+    model,
+    timeout,
+}: {
+    baseUrl: string;
+    model: string;
+    timeout: number;
+}): Promise<number> => {
+    const response = await fetch(`${baseUrl}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model }),
+        signal: AbortSignal.timeout(timeout),
+    });
+    if (!response.ok) throw new Error(`ollama provider: /api/show returned ${response.status}`);
+    const data = await response.json() as ShowResponse;
+    for (const [key, value] of Object.entries(data.model_info ?? {})) {
+        if (key.endsWith(".context_length") && typeof value === "number" && value > 0) return value;
+    }
+    throw new Error(`ollama provider: /api/show has no *.context_length key for "${model}"`);
+};
+
+export const ollamaProviderFromEnv = async (
+    env: NodeJS.ProcessEnv,
+    model: string,
+    options?: ProviderOptions,
+): Promise<Provider> => {
+    const configured = options?.baseUrl ?? env.OLLAMA_BASE_URL ?? env.OLLAMA_HOST;
+    const baseUrl = requireEnv(
+        configured,
+        "OLLAMA_BASE_URL or OLLAMA_HOST (or a PLURNK_BASEURL_<alias> override)",
+        "ollama",
+    ).replace(/\/+$/, "").replace(/\/v1$/, "");
+    const timeout = parseRequiredInt(
+        env.PLURNK_PROVIDERS_FETCH_TIMEOUT,
+        "PLURNK_PROVIDERS_FETCH_TIMEOUT",
+        "ollama",
+    );
+    const contextWindow = contextWindowFromEnv(env, "ollama")
+        ?? await fetchContextWindow({ baseUrl, model, timeout });
+    const languageModel = createOpenAICompatible({
+        name: "ollama",
+        baseURL: `${baseUrl}/v1`,
+        includeUsage: true,
+    }).languageModel(model);
+    return providerFromSdkModel({
+        name: "ollama",
+        env,
+        model,
+        languageModel,
+        contextWindow,
+    });
+};

package/src/openai.ts

@@ -1,11 +1,5 @@
-export { default as OpenAICompatProvider, effortFromBudget } from "./OpenAICompat.ts";
-export type { GrammarStyle, OpenAICompatConfig, ReasoningStyle } from "./OpenAICompat.ts";
-export { chatCompletion, chatCompletionStream, OpenAiHttpError, StreamIdleError } from "./openaiStream.ts";
-export type {
-    EncryptedReasoningItem,
-    ProviderFetch,
-    StreamResponse,
-} from "./openaiStream.ts";
+export { default as AiSdkProvider, effortFromBudget } from "./AiSdkProvider.ts";
+export type { AiSdkProviderConfig, GrammarStyle, ProviderFetch, ReasoningStyle } from "./AiSdkProvider.ts";
 export type {
     ChatMessage,
     FinishReason,

package/src/sdkModels.test.ts

@@ -0,0 +1,47 @@
+import test from "node:test";
+import { strict as assert } from "node:assert";
+import { configuredProviderInfo, createSdkModel } from "./sdkModels.ts";
+
+test("configuredProviderInfo translates one env declaration into provider facts", () => {
+    assert.deepEqual(configuredProviderInfo("acme-cloud", {
+        PLURNK_PROVIDERS_PROVIDER_ACME_CLOUD_NPM: "@ai-sdk/openai-compatible",
+        PLURNK_PROVIDERS_PROVIDER_ACME_CLOUD_BASE_URL: "https://api.acme.test/v1",
+        PLURNK_PROVIDERS_PROVIDER_ACME_CLOUD_API_KEY_ENV: "ACME_API_KEY, ACME_TOKEN",
+    }), {
+        id: "acme-cloud",
+        npm: "@ai-sdk/openai-compatible",
+        env: ["ACME_API_KEY", "ACME_TOKEN"],
+        api: "https://api.acme.test/v1",
+    });
+});
+
+test("createSdkModel uses Models.dev provider facts and operator credentials", () => {
+    const sdk = createSdkModel("xai", "grok-build-0.1", { XAI_API_KEY: "test-key" });
+    assert.notEqual(sdk, null);
+    assert.equal(sdk?.catalog?.npm, "@ai-sdk/xai");
+    const languageModel = sdk?.languageModel as { provider: string; modelId: string };
+    assert.equal(languageModel.provider, "xai.responses");
+    assert.equal(languageModel.modelId, "grok-build-0.1");
+});
+
+test("createSdkModel expands catalog endpoint variables without treating them as credentials", () => {
+    const sdk = createSdkModel("cloudflare", "@cf/google/gemma-4-26b-a4b-it", {
+        CLOUDFLARE_ACCOUNT_ID: "account",
+        CLOUDFLARE_API_TOKEN: "token",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_API_KEY_ENV: "CLOUDFLARE_API_TOKEN,CLOUDFLARE_API_KEY",
+    });
+    assert.equal(sdk?.languageModel, undefined);
+    assert.deepEqual(sdk?.compatible, {
+        url: "https://api.cloudflare.com/client/v4/accounts/account/ai/v1/chat/completions",
+        headers: { Authorization: "Bearer token" },
+    });
+});
+
+test("createSdkModel fails clearly for a declared but unsupported SDK package", () => {
+    assert.throws(
+        () => createSdkModel("acme", "model", {
+            PLURNK_PROVIDERS_PROVIDER_ACME_NPM: "@acme/ai-sdk",
+        }),
+        /Models.dev declares unsupported AI SDK package @acme\/ai-sdk/,
+    );
+});

package/src/sdkModels.ts

@@ -0,0 +1,194 @@
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createDeepInfra } from "@ai-sdk/deepinfra";
+import { createGoogle } from "@ai-sdk/google";
+import { createGroq } from "@ai-sdk/groq";
+import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createTogetherAI } from "@ai-sdk/togetherai";
+import { createXai } from "@ai-sdk/xai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { lookupProvider, type ProviderInfo } from "@plurnk/plurnk-models";
+import type { LanguageModel } from "ai";
+
+export type SdkModel = {
+    readonly languageModel?: LanguageModel;
+    readonly compatible?: {
+        readonly url: string;
+        readonly headers: Readonly<Record<string, string>>;
+    };
+    readonly catalog: ProviderInfo | null;
+};
+
+const envPrefix = (provider: string): string =>
+    provider.replaceAll(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+
+export const configuredProviderInfo = (
+    provider: string,
+    env: NodeJS.ProcessEnv,
+): ProviderInfo | null => {
+    const prefix = `PLURNK_PROVIDERS_PROVIDER_${envPrefix(provider)}`;
+    const npm = env[`${prefix}_NPM`];
+    if (npm === undefined || npm.length === 0) return null;
+    const keyNames = env[`${prefix}_API_KEY_ENV`]
+        ?.split(",")
+        .map((name) => name.trim())
+        .filter(Boolean) ?? [];
+    const api = env[`${prefix}_BASE_URL`];
+    return {
+        id: provider,
+        npm,
+        env: keyNames,
+        ...(api === undefined || api.length === 0 ? {} : { api }),
+    };
+};
+
+const firstSet = (env: NodeJS.ProcessEnv, names: readonly string[]): string | undefined => {
+    for (const name of names) {
+        const value = env[name];
+        if (value !== undefined && value.length > 0) return value;
+    }
+    return undefined;
+};
+
+const configuredKeyNames = (
+    provider: string,
+    env: NodeJS.ProcessEnv,
+    catalog: ProviderInfo,
+): readonly string[] => {
+    const configured = env[`PLURNK_PROVIDERS_PROVIDER_${envPrefix(provider)}_API_KEY_ENV`];
+    return configured === undefined || configured.length === 0
+        ? catalog.env
+        : configured.split(",").map((name) => name.trim()).filter(Boolean);
+};
+
+const expandEnv = (value: string, env: NodeJS.ProcessEnv, provider: string): string =>
+    value.replaceAll(/\$\{([A-Z0-9_]+)\}/g, (_match, name: string) => {
+        const replacement = env[name];
+        if (replacement === undefined || replacement.length === 0) {
+            throw new Error(`${provider} provider: ${name} must be set to resolve the Models.dev API URL`);
+        }
+        return replacement;
+    });
+
+const baseUrl = (
+    provider: string,
+    env: NodeJS.ProcessEnv,
+    catalog: ProviderInfo,
+    override?: string,
+): string | undefined => {
+    const prefix = envPrefix(provider);
+    const configured = env[`PLURNK_PROVIDERS_PROVIDER_${prefix}_BASE_URL`]
+        ?? env[`${prefix}_BASE_URL`]
+        ?? catalog.api;
+    const value = override ?? configured;
+    return value === undefined ? undefined : expandEnv(value, env, provider).replace(/\/+$/, "");
+};
+
+const apiKey = (
+    provider: string,
+    env: NodeJS.ProcessEnv,
+    catalog: ProviderInfo,
+): string | undefined => firstSet(env, configuredKeyNames(provider, env, catalog));
+
+const requireApiKey = (
+    provider: string,
+    env: NodeJS.ProcessEnv,
+    catalog: ProviderInfo,
+): string => {
+    const names = configuredKeyNames(provider, env, catalog);
+    const key = firstSet(env, names);
+    if (key === undefined) throw new Error(`${provider} provider: ${names.join(" or ")} must be set`);
+    return key;
+};
+
+export const createSdkModel = (
+    provider: string,
+    model: string,
+    env: NodeJS.ProcessEnv,
+    baseUrlOverride?: string,
+): SdkModel | null => {
+    const catalog = lookupProvider(provider) ?? configuredProviderInfo(provider, env);
+    if (catalog === null) return null;
+    const url = baseUrl(provider, env, catalog, baseUrlOverride);
+
+    switch (catalog.npm) {
+        case "@ai-sdk/openai":
+            return {
+                languageModel: createOpenAI({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).chat(model),
+                catalog,
+            };
+        case "@ai-sdk/groq":
+            return {
+                languageModel: createGroq({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/mistral":
+            return {
+                languageModel: createMistral({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/togetherai":
+            return {
+                languageModel: createTogetherAI({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/deepinfra":
+            return {
+                languageModel: createDeepInfra({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/google":
+            return {
+                languageModel: createGoogle({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/xai":
+            return {
+                languageModel: createXai({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/anthropic":
+            return {
+                languageModel: createAnthropic({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/amazon-bedrock":
+            return {
+                languageModel: createAmazonBedrock({
+                    region: env.AWS_REGION ?? env.AWS_DEFAULT_REGION,
+                    accessKeyId: env.AWS_ACCESS_KEY_ID,
+                    secretAccessKey: env.AWS_SECRET_ACCESS_KEY,
+                    sessionToken: env.AWS_SESSION_TOKEN,
+                    apiKey: env.AWS_BEARER_TOKEN_BEDROCK,
+                    baseURL: url,
+                }).languageModel(model),
+                catalog,
+            };
+        case "@openrouter/ai-sdk-provider":
+            return {
+                languageModel: createOpenRouter({
+                    apiKey: requireApiKey(provider, env, catalog),
+                    baseURL: url,
+                    headers: {
+                        ...(env.OPENROUTER_HTTP_REFERER === undefined ? {} : { "HTTP-Referer": env.OPENROUTER_HTTP_REFERER }),
+                        ...(env.OPENROUTER_X_TITLE === undefined ? {} : { "X-Title": env.OPENROUTER_X_TITLE }),
+                    },
+                }).languageModel(model),
+                catalog,
+            };
+        case "@ai-sdk/openai-compatible":
+            if (url === undefined) throw new Error(`${provider} provider: Models.dev supplies no API URL and no base URL was configured`);
+            return {
+                compatible: {
+                    url: `${url}/chat/completions`,
+                    headers: apiKey(provider, env, catalog) === undefined
+                        ? {}
+                        : { Authorization: `Bearer ${apiKey(provider, env, catalog)}` },
+                },
+                catalog,
+            };
+        default:
+            throw new Error(`${provider} provider: Models.dev declares unsupported AI SDK package ${catalog.npm}`);
+    }
+};

package/src/telemetry.test.ts

@@ -1,7 +1,15 @@
 import test from "node:test";
 import { strict as assert } from "node:assert";
+import { APICallError } from "ai";
 import { ProviderError, classifyProviderError, toProviderError, providerSource } from "./telemetry.ts";
-import { OpenAiHttpError } from "./openaiStream.ts";
+
+const apiError = (statusCode: number, responseBody = "body") => new APICallError({
+    message: `request failed (${statusCode})`,
+    url: "https://example.test/v1/chat/completions",
+    requestBodyValues: {},
+    statusCode,
+    responseBody,
+});
 
 // Schema pattern for TelemetryEvent.source (from grammar's TelemetryEvent.json).
 const SOURCE_PATTERN = /^[a-z]+(:[a-z][a-z0-9-]*)?$/;
@@ -13,7 +21,7 @@ test("providerSource produces a schema-valid colon-namespaced source", () => {
 });
 
 test("classifyProviderError maps HTTP status to kind", () => {
-    const k = (status: number) => classifyProviderError(new OpenAiHttpError(status, "body", null)).kind;
+    const k = (status: number) => classifyProviderError(apiError(status)).kind;
     assert.equal(k(401), "unauthorized");
     assert.equal(k(403), "unauthorized");
     assert.equal(k(402), "quota_exceeded");
@@ -24,13 +32,11 @@ test("classifyProviderError maps HTTP status to kind", () => {
     assert.equal(k(404), "invalid_response");
 });
 
-test("classifyProviderError: a 422 flagged grammar_invalid is transient (#548); other 422s terminal", () => {
-    const rejected = new OpenAiHttpError(422, JSON.stringify({ error: { type: "grammar_invalid", message: "non-conforming emission rejected: ..." } }), null);
+test("classifyProviderError: a 422 flagged grammar_invalid is distinct (#548); other 422s are invalid responses", () => {
+    const rejected = apiError(422, JSON.stringify({ error: { type: "grammar_invalid", message: "non-conforming emission rejected: ..." } }));
     assert.equal(classifyProviderError(rejected).kind, "grammar_invalid");
-    // a 422 carrying any other error.type is a malformed request — terminal
-    assert.equal(classifyProviderError(new OpenAiHttpError(422, JSON.stringify({ error: { type: "invalid_request_error" } }), null)).kind, "invalid_response");
-    // a non-JSON 422 body (edge/proxy HTML) is terminal, and the sniff does not throw
-    assert.equal(classifyProviderError(new OpenAiHttpError(422, "<html>Bad</html>", null)).kind, "invalid_response");
+    assert.equal(classifyProviderError(apiError(422, JSON.stringify({ error: { type: "invalid_request_error" } }))).kind, "invalid_response");
+    assert.equal(classifyProviderError(apiError(422, "<html>Bad</html>")).kind, "invalid_response");
 });
 
 test("classifyProviderError treats non-HTTP errors as network_failure", () => {
@@ -49,11 +55,12 @@ test("ProviderError.toTelemetryEvent emits the canonical envelope", () => {
 });
 
 test("toProviderError classifies and tags an HTTP error with the source + status", () => {
-    const pe = toProviderError(new OpenAiHttpError(401, "no key", null), "provider:groq");
+    const cause = apiError(401, "no key");
+    const pe = toProviderError(cause, "provider:groq");
     assert.equal(pe.kind, "unauthorized");
     assert.equal(pe.source, "provider:groq");
     assert.equal(pe.status, 401);
-    assert.equal(pe.cause instanceof OpenAiHttpError, true); // original preserved
+    assert.equal(pe.cause, cause);
 });
 
 test("toProviderError passes an existing ProviderError through unchanged", () => {

package/src/telemetry.ts

@@ -6,7 +6,7 @@
 // dependency on grammar (see SPEC §11). Consumers route provider events through
 // the same `source` + `kind` discriminator as parse/rail events.
 
-import { OpenAiHttpError } from "./openaiStream.ts";
+import { APICallError, RetryError } from "ai";
 
 // Required by the schema: source (producer id) + kind (discriminator). message
 // and position are optional. A transport failure isn't localizable, so it carries
@@ -29,11 +29,9 @@ export type ProviderTelemetryKind =
     | "invalid_response"
     | "unauthorized"
     | "quota_exceeded"
-    // A 422 whose error.type is "grammar_invalid" (#548): the backend served ONE
-    // generation and rejected it as non-conforming. Transient, not terminal — a
-    // fresh sample may conform — so it rides the retry budget. Distinct from
-    // grammar_unenforced below: that observes a SUCCEEDED exchange; this is a
-    // thrown transport failure the daemon retries, then fails as a leaf.
+    // A 422 whose error.type is "grammar_invalid" (#548): the backend served one
+    // generation and rejected it as non-conforming. This identifies the failure;
+    // whether to start another model exchange belongs to the engine.
     | "grammar_invalid"
     // Output did not conform to the GBNF. ALWAYS an observation, never a throw:
     // a completed exchange returns its bytes with this event on
@@ -80,18 +78,27 @@ const wireErrorType = (body: string): string | null => {
 // Map a thrown transport error to a (kind, message). Conservative; the message
 // is factual, no guidance prose (consumer SPEC §15.1 policy).
 export const classifyProviderError = (err: unknown): { kind: ProviderTelemetryKind; message: string } => {
-    if (err instanceof OpenAiHttpError) {
-        const { status, message } = err;
+    if (RetryError.isInstance(err)) return classifyProviderError(err.lastError);
+    if (APICallError.isInstance(err)) {
+        const status = err.statusCode ?? 0;
+        const message = err.message;
+        const body = err.responseBody ?? "";
         if (status === 401 || status === 403) return { kind: "unauthorized", message };
         if (status === 402) return { kind: "quota_exceeded", message };
         if (status === 429) return { kind: "rate_limit", message };
         if (status >= 500) return { kind: "network_failure", message };
-        // A 422 flagged grammar_invalid is a stochastic output reject (#548) — one
-        // generation served then rejected, so a fresh sample may conform: transient.
-        // Any other 422 is a malformed request: terminal (invalid_response).
-        if (status === 422 && wireErrorType(err.body) === "grammar_invalid") return { kind: "grammar_invalid", message };
+        // A flagged 422 identifies a grammar-rejected exchange. It is not
+        // transport replay policy; the engine decides whether to sample again.
+        if (status === 422 && wireErrorType(body) === "grammar_invalid") return { kind: "grammar_invalid", message };
         return { kind: "invalid_response", message };
     }
+    const wire = err as { message?: unknown; type?: unknown; status?: unknown };
+    if (wire?.type === "grammar_invalid") {
+        return {
+            kind: "grammar_invalid",
+            message: typeof wire.message === "string" ? wire.message : "grammar-invalid response",
+        };
+    }
     const e = err as { name?: string; message?: string };
     const message = (e?.message ?? String(err)) || "request failed";
     // Timeouts / fetch-level failures are transport, not a usable response.
@@ -102,7 +109,8 @@ export const classifyProviderError = (err: unknown): { kind: ProviderTelemetryKi
 // Already-classified errors pass through unchanged.
 export const toProviderError = (err: unknown, source: string): ProviderError => {
     if (err instanceof ProviderError) return err;
-    const { kind, message } = classifyProviderError(err);
-    const status = err instanceof OpenAiHttpError ? err.status : null;
+    const underlying = RetryError.isInstance(err) ? err.lastError : err;
+    const { kind, message } = classifyProviderError(underlying);
+    const status = APICallError.isInstance(underlying) ? underlying.statusCode ?? null : null;
     return new ProviderError(source, kind, message, { status, cause: err });
 };

package/src/types.ts

@@ -3,6 +3,7 @@
 // is the wire-reported CoT only.
 
 import type { TelemetryEvent } from "./telemetry.ts";
+import type { LanguageModel } from "ai";
 
 export interface ChatMessage {
     role: "system" | "user" | "assistant";
@@ -208,12 +209,8 @@ export interface ProviderOptions {
     readonly baseUrl?: string;
 }
 
-// Each provider package's default export MUST be a factory:
-//   static fromEnv(env, model, options?) → Provider | Promise<Provider>
-// `model` is the second positional arg because PLURNK_MODEL_<alias>=<provider>/<model>
-// is parsed by the registry; the resolved model id flows through. `options` is an
-// optional third arg (per-alias overrides, e.g. baseUrl); a factory that ignores
-// it keeps working unchanged.
-export interface ProviderFactory {
-    fromEnv(env: NodeJS.ProcessEnv, model: string, options?: ProviderOptions): Provider | Promise<Provider>;
+// A discovered provider plugin default-exports an AI SDK provider. PLURNK owns
+// the adapter into Provider; the plugin owns only its protocol binding.
+export interface AiSdkProviderPlugin {
+    languageModel(model: string): LanguageModel;
 }