@plurnk/plurnk-providers 1.3.12 → 1.4.0

package/src/compatibleProvider.test.ts

@@ -13,6 +13,7 @@ const env = {
     PLURNK_PROVIDERS_REASONING_RESERVE: "10%",
     PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%",
     PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
+    PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512",
     PLURNK_PROVIDERS_PROBE_ATTEMPTS: "1",
     PLURNK_PROVIDERS_PROBE_DELAY: "0",
     PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
@@ -42,3 +43,98 @@ test("compatible endpoints preserve configured prompt-cache affinity", async ()
 
     assert.equal(body?.prompt_cache_key, "worker-affinity");
 });
+
+test("the server-wide DRY-off floor emits no DRY request fields", async () => {
+    let body: Record<string, unknown> | undefined;
+    mock.method(globalThis, "fetch", async (input: string | URL | Request, init?: RequestInit) => {
+        if (String(input).endsWith("/models")) {
+            return new Response(JSON.stringify({
+                data: [{ id: "local", meta: { n_ctx: 8192 } }],
+            }));
+        }
+        body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+        return new Response(JSON.stringify({
+            model: "local",
+            choices: [{ message: { content: "ok" }, finish_reason: "stop" }],
+            usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }), { headers: { "content-type": "application/json" } });
+    });
+
+    const provider = await compatibleProviderFromEnv("openai", {
+        ...env,
+        PLURNK_PROVIDERS_DRY_MULTIPLIER: "0",
+        // Stale or independently supplied shape values cannot activate DRY.
+        PLURNK_PROVIDERS_DRY_BASE: "1.75",
+        PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH: "32",
+    }, "local");
+    await provider.generate({
+        workerId: "worker-dry-off",
+        messages: [{ role: "user", content: "repeat exactly" }],
+    });
+
+    assert.equal(body?.repeat_penalty, 1.15);
+    assert.equal("dry_multiplier" in (body ?? {}), false);
+    assert.equal("dry_base" in (body ?? {}), false);
+    assert.equal("dry_allowed_length" in (body ?? {}), false);
+});
+
+test("detected llama-server measures the complete chat request through input_tokens", async () => {
+    let countUrl: string | undefined;
+    let countBody: Record<string, unknown> | undefined;
+    mock.method(globalThis, "fetch", async (input: string | URL | Request, init?: RequestInit) => {
+        const url = String(input);
+        if (url.endsWith("/models")) {
+            return new Response(JSON.stringify({
+                data: [{ id: "served.gguf", meta: { n_ctx: 8192 } }],
+            }));
+        }
+        if (url.endsWith("/props")) {
+            return new Response(JSON.stringify({ total_slots: 1 }));
+        }
+        if (url.endsWith("/chat/completions/input_tokens")) {
+            countUrl = url;
+            countBody = JSON.parse(String(init?.body)) as Record<string, unknown>;
+            return new Response(JSON.stringify({ input_tokens: 37 }), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        throw new Error(`unexpected request ${url}`);
+    });
+
+    const provider = await compatibleProviderFromEnv("openai", env, "local");
+    const messages = [
+        { role: "system" as const, content: "system slot" },
+        { role: "user" as const, content: "漢漢漢" },
+    ];
+    assert.deepEqual(await provider.countPromptTokens(messages), {
+        kind: "exact",
+        tokens: 37,
+        source: "llama-server:/v1/chat/completions/input_tokens",
+    });
+    assert.equal(countUrl, "http://local.test/v1/chat/completions/input_tokens");
+    assert.deepEqual(countBody?.messages, messages, "measurement receives the exact dispatched message slots");
+    assert.equal(countBody?.model, "local");
+    assert.deepEqual(countBody?.chat_template_kwargs, { enable_thinking: false });
+});
+
+test("a missing llama-server input-token endpoint degrades explicitly, never to a claimed bound", async () => {
+    mock.method(globalThis, "fetch", async (input: string | URL | Request) => {
+        const url = String(input);
+        if (url.endsWith("/models")) {
+            return new Response(JSON.stringify({
+                data: [{ id: "served.gguf", meta: { n_ctx: 8192 } }],
+            }));
+        }
+        if (url.endsWith("/props")) return new Response(JSON.stringify({ total_slots: 1 }));
+        if (url.endsWith("/chat/completions/input_tokens")) return new Response("missing", { status: 404 });
+        throw new Error(`unexpected request ${url}`);
+    });
+
+    const provider = await compatibleProviderFromEnv("openai", env, "local");
+    assert.deepEqual(await provider.countPromptTokens([{ role: "user", content: "漢漢漢" }]), {
+        kind: "estimate",
+        tokens: 2,
+        source: "heuristic:chars2",
+        detail: "llama-server input-token endpoint returned HTTP 404",
+    });
+});

package/src/compatibleProvider.ts

@@ -1,6 +1,7 @@
 import AiSdkProvider, { type GrammarStyle, type ReasoningStyle } from "./AiSdkProvider.ts";
 import {
     contextWindowFromEnv,
+    effectiveContextWindow,
     dataCaptureFromEnv,
     envelopeFromEnv,
     parseOptionalFloat,
@@ -9,8 +10,9 @@ import {
     parseRequiredInt,
     promptCacheKeyFromEnv,
     reasoningFromEnv,
+    reasoningResponseStyleFromEnv,
 } from "./env.ts";
-import { providerSource } from "./telemetry.ts";
+import { providerSource } from "./notices.ts";
 import type { Provider } from "./types.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -125,7 +127,7 @@ export const compatibleProviderFromEnv = async (
         attempts,
         parseRequiredInt(env.PLURNK_PROVIDERS_PROBE_DELAY, "PLURNK_PROVIDERS_PROBE_DELAY", provider),
     );
-    let contextWindow = contextWindowFromEnv(env, provider) ?? probe.nCtx;
+    const contextWindow = effectiveContextWindow(contextWindowFromEnv(env, provider), probe.nCtx);
     const pinRaw = env.PLURNK_PROVIDERS_LLAMA_SERVER;
     if (pinRaw !== undefined && pinRaw !== "" && pinRaw !== "0" && pinRaw !== "1") {
         throw new Error(`${provider} provider: PLURNK_PROVIDERS_LLAMA_SERVER must be "1", "0", or unset`);
@@ -150,6 +152,7 @@ export const compatibleProviderFromEnv = async (
     let slotCount: number | null = null;
     let eosText: string | undefined;
     let tokenizeUrl: string | undefined;
+    let promptTokensUrl: string | undefined;
     if (llamaServer) {
         grammarStyle = "llamacpp";
         reasoningStyle = "template";
@@ -157,12 +160,15 @@ export const compatibleProviderFromEnv = async (
         slotCount = props.slotCount;
         eosText = props.eosText ?? undefined;
         tokenizeUrl = url.replace(/\/v1\/chat\/completions$/, "/tokenize");
+        promptTokensUrl = url.replace(/\/v1\/chat\/completions$/, "/v1/chat/completions/input_tokens");
     }
 
-    emitWarningOnce(
-        `${provider} provider: countTokens is a chars/2 upper bound — exact counts come from the mimetypes tokenizer seam or tokenize()`,
-        "PLURNK_TOKENIZER_HEURISTIC",
-    );
+    if (!llamaServer) {
+        emitWarningOnce(
+            `${provider} provider: physical prompt counting is a chars/2 estimate; over-policy recovery fails closed without exact or bounded request evidence`,
+            "PLURNK_PROMPT_COUNT_ESTIMATE",
+        );
+    }
     const { reasoningReserve, completionReserve } = envelopeFromEnv(env, provider);
     return new AiSdkProvider({
         model,
@@ -172,6 +178,7 @@ export const compatibleProviderFromEnv = async (
         fetchTimeoutMs: timeout,
         streamIdleTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", provider),
         reasoning: reasoningFromEnv(env, provider),
+        reasoningResponseStyle: reasoningResponseStyleFromEnv(env, provider),
         reasoningStyle,
         temperature: parseRequiredFloat(env.PLURNK_PROVIDERS_TEMPERATURE, "PLURNK_PROVIDERS_TEMPERATURE", provider, 0),
         repeatPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_REPEAT_PENALTY, "PLURNK_PROVIDERS_REPEAT_PENALTY", provider, 0),
@@ -184,6 +191,7 @@ export const compatibleProviderFromEnv = async (
         completionReserve,
         tuningFloors: provider !== "plurnk",
         retryAttempts: parseRequiredInt(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "PLURNK_PROVIDERS_RETRY_ATTEMPTS", provider),
+        errorDetailLimit: parseRequiredInt(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT", provider),
         promptCacheKey: promptCacheKeyFromEnv(env, provider),
         source: providerSource(provider),
         grammarStyle,
@@ -199,6 +207,7 @@ export const compatibleProviderFromEnv = async (
         slotCount,
         eosText,
         tokenizeUrl,
+        promptTokensUrl,
         servedModel: probe.servedModel ?? undefined,
         requiresMaxTokens: llamaServer || undefined,
     });

package/src/cost.test.ts

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+    providerCostFor,
+    providerCostUsd,
+    validateAuthoritativeCharge,
+} from "./cost.ts";
+import type { ProviderUsage } from "./types.ts";
+
+const usage: ProviderUsage = {
+    prompt: 1,
+    completion: 1,
+    reasoning: 0,
+    cached: 0,
+    total: 2,
+};
+
+test("authoritative provider charge wins over a local estimate", () => {
+    const provider = {
+        calculateCost: () => 12,
+        calculateCharge: () => ({ kind: "estimated", usd: "12", source: "catalog" } as const),
+    };
+    const charge = {
+        kind: "authoritative",
+        amount: { amount: "0.0000042", currency: "XMR" },
+        usdEquivalent: "0.73",
+        source: "settled upstream turn charge",
+    } as const;
+    assert.deepEqual(providerCostFor(provider, usage, charge), charge);
+    assert.equal(providerCostUsd(charge), 0.73);
+});
+
+test("explicit free remains distinguishable from unknown", () => {
+    const free = providerCostFor({
+        calculateCost: () => 0,
+        calculateCharge: () => ({ kind: "free", source: "local model" }),
+    }, usage);
+    const unknown = providerCostFor({ calculateCost: () => 0 }, usage);
+    assert.deepEqual(free, { kind: "free", source: "local model" });
+    assert.deepEqual(unknown, {
+        kind: "unknown",
+        reason: "legacy calculateCost returned zero without free-cost authority",
+    });
+    assert.equal(providerCostUsd(free), 0);
+    assert.equal(providerCostUsd(unknown), null);
+});
+
+test("positive legacy cost remains an estimated USD compatibility result", () => {
+    assert.deepEqual(providerCostFor({ calculateCost: () => 0.25 }, usage), {
+        kind: "estimated",
+        usd: "0.25",
+        source: "legacy calculateCost",
+    });
+});
+
+test("rejects malformed money instead of mining or coercing it", () => {
+    assert.throws(() => validateAuthoritativeCharge({
+        kind: "authoritative",
+        amount: { amount: "1e3", currency: "usd" },
+        usdEquivalent: "1000",
+        source: "wire",
+    }), /canonical non-negative decimal string/);
+});

package/src/cost.ts

@@ -0,0 +1,83 @@
+import type {
+    AuthoritativeCharge,
+    ProviderUsage,
+} from "./types.ts";
+import type { ProviderCost } from "@plurnk/plurnk-contracts";
+
+const DECIMAL = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+const CURRENCY = /^[A-Z][A-Z0-9]{2,11}$/;
+
+const nonEmpty = (value: string, name: string): string => {
+    if (value.trim() === "") throw new TypeError(`${name} must be non-empty`);
+    return value;
+};
+
+const decimal = (value: string, name: string): string => {
+    if (!DECIMAL.test(value)) throw new TypeError(`${name} must be a canonical non-negative decimal string`);
+    return value;
+};
+
+export const validateAuthoritativeCharge = (charge: AuthoritativeCharge): AuthoritativeCharge => {
+    if (charge.kind !== "authoritative") throw new TypeError("provider charge must be authoritative");
+    decimal(charge.amount.amount, "provider charge amount");
+    if (!CURRENCY.test(charge.amount.currency)) {
+        throw new TypeError("provider charge currency must be an uppercase currency code");
+    }
+    decimal(charge.usdEquivalent, "provider charge USD equivalent");
+    nonEmpty(charge.source, "provider charge source");
+    return charge;
+};
+
+export const validateProviderCost = (cost: ProviderCost): ProviderCost => {
+    switch (cost.kind) {
+        case "authoritative":
+            return validateAuthoritativeCharge(cost);
+        case "estimated":
+            decimal(cost.usd, "provider cost estimate");
+            nonEmpty(cost.source, "provider cost estimate source");
+            return cost;
+        case "free":
+            nonEmpty(cost.source, "provider free source");
+            return cost;
+        case "unknown":
+            nonEmpty(cost.reason, "provider unknown-cost reason");
+            return cost;
+    }
+};
+
+export const resolveProviderCost = (
+    charge: AuthoritativeCharge | undefined,
+    current: ProviderCost | undefined,
+    legacy: () => number,
+): ProviderCost => {
+    if (charge !== undefined) return validateAuthoritativeCharge(charge);
+    if (current !== undefined) return validateProviderCost(current);
+    const cost = legacy();
+    if (!Number.isFinite(cost) || cost < 0) {
+        throw new TypeError("legacy provider cost must be a finite non-negative number");
+    }
+    return cost > 0
+        ? { kind: "estimated", usd: String(cost), source: "legacy calculateCost" }
+        : { kind: "unknown", reason: "legacy calculateCost returned zero without free-cost authority" };
+};
+
+export const providerCostUsd = (cost: ProviderCost): number | null => {
+    const value = cost.kind === "authoritative"
+        ? cost.usdEquivalent
+        : cost.kind === "estimated"
+            ? cost.usd
+            : cost.kind === "free"
+                ? "0"
+                : null;
+    return value === null ? null : Number(value);
+};
+
+export const providerCostFor = (
+    provider: { calculateCharge?(usage: ProviderUsage): Exclude<ProviderCost, AuthoritativeCharge>; calculateCost(usage: ProviderUsage): number },
+    usage: ProviderUsage,
+    charge?: AuthoritativeCharge,
+): ProviderCost => resolveProviderCost(
+    charge,
+    provider.calculateCharge?.(usage),
+    () => provider.calculateCost(usage),
+);

package/src/defaults.test.ts

@@ -7,6 +7,7 @@ test("withProviderDefaults supplies the package-owned operational floor", () =>
     assert.equal(env.PLURNK_PROVIDERS_PROMPT_CACHE_KEY, "1");
     assert.equal(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "600000");
     assert.equal(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "3");
+    assert.equal(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "512");
 });
 
 test("withProviderDefaults preserves every explicit operator value", () => {

package/src/discover.test.ts

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { discover } from "./discover.ts";
 
-// #551: create a temp dir AND register its removal on the test context, so it's
+// Create a temp dir and register its removal on the test context, so it is
 // cleaned on a GREEN or RED run. A trailing rm after the assertions leaks the dir
 // whenever one throws — thousands accumulate on a shared box at drill frequency.
 const tempDir = async (t: TestContext, prefix: string): Promise<string> => {
@@ -47,6 +47,17 @@ test("discover: a provider package missing plurnk.name is ignored, not crashed",
     assert.deepEqual([...registry.keys()], ["named"]);
 });
 
+test("discover: an array kind claims no provider family", async (t) => {
+    const root = await buildModules(t, {
+        "@acme/dual": {
+            name: "@acme/dual",
+            plurnk: { kind: ["provider", "scheme"], name: "dual" },
+        },
+    });
+    const { registry } = await discover({ cwd: root });
+    assert.equal(registry.size, 0);
+});
+
 test("discover: a name claimed by two packages is a fail-hard collision", async (t) => {
     const root = await buildModules(t, {
         "@plurnk/plurnk-provider-native": { name: "@plurnk/plurnk-provider-native", plurnk: { kind: "provider", name: "native" } },
@@ -71,18 +82,48 @@ test("discover: node_modules entries with no package.json or malformed JSON are
     assert.deepEqual([...registry.keys()], ["native"]); // only the well-formed provider survives
 });
 
-test("discover: surfaces plurnk.attribution (string or string[]) for registered providers (#21)", async (t) => {
+test("discover: normalizes attribution per package and preserves the published provider projection", async (t) => {
     const root = await buildModules(t, {
         "@acme/provider-solo": { name: "@acme/provider-solo", plurnk: { kind: "provider", name: "solo", attribution: "@acme/solo" } },
         "@acme/provider-multi": { name: "@acme/provider-multi", plurnk: { kind: "provider", name: "multi", attribution: ["@acme/a", "@acme/b"] } },
         "@acme/provider-none": { name: "@acme/provider-none", plurnk: { kind: "provider", name: "none" } },
-        "@acme/provider-bad": { name: "@acme/provider-bad", plurnk: { kind: "provider", name: "bad", attribution: 42 } }, // non-string/array
     });
-    const { attributions } = await discover({ cwd: root });
+    const { attributions, packageAttributions } = await discover({ cwd: root });
     assert.equal(attributions.get("solo"), "@acme/solo");
     assert.deepEqual(attributions.get("multi"), ["@acme/a", "@acme/b"]);
-    assert.equal(attributions.has("none"), false); // declared none → absent
-    assert.equal(attributions.has("bad"), false);  // non-string/array ignored, not surfaced
+    assert.equal(attributions.has("none"), false);
+    assert.deepEqual([...packageAttributions], [
+        ["@acme/provider-multi", ["@acme/a", "@acme/b"]],
+        ["@acme/provider-solo", ["@acme/solo"]],
+    ]);
+});
+
+test("discover: validates trusted attribution before provider admission", async (t) => {
+    const root = await buildModules(t, {
+        "@acme/provider-bad": { name: "@acme/provider-bad", plurnk: { kind: "provider", name: "bad", attribution: 42 } },
+    });
+    await assert.rejects(
+        discover({ cwd: root }),
+        /plugin '@acme\/provider-bad': plurnk\.attribution must be a non-empty string or string\[\]/,
+    );
+
+    const reservedRoot = await buildModules(t, {
+        "@acme/provider-reserved": { name: "@acme/provider-reserved", plurnk: { kind: "provider", name: "reserved", attribution: "@plurnk/staff" } },
+    });
+    await assert.rejects(discover({ cwd: reservedRoot }), /'@plurnk\/' is reserved/);
+});
+
+test("discover: an untrusted malformed attribution is withheld before validation", async (t) => {
+    const root = await buildModules(t, {
+        "@acme/provider-bad": { name: "@acme/provider-bad", plurnk: { kind: "provider", name: "bad", attribution: ["ok", 42] } },
+    });
+    const result = await discover({
+        cwd: root,
+        env: { PLURNK_PLUGINS_TRUSTED_ONLY: "1" } as NodeJS.ProcessEnv,
+    });
+    assert.equal(result.registry.size, 0);
+    assert.equal(result.skipped.get("bad"), "@acme/provider-bad");
+    assert.equal(result.packageAttributions.size, 0);
 });
 
 test("discover: missing node_modules yields an empty registry, not an error", async (t) => {
@@ -91,7 +132,7 @@ test("discover: missing node_modules yields an empty registry, not an error", as
     assert.equal(registry.size, 0);
 });
 
-// — trust gate (PLURNK_PLUGINS_TRUSTED_ONLY, #15) —
+// — trust gate ({§plugin-trust-boundary}) —
 
 const trustFixture = (t: TestContext) => buildModules(t, {
     "@plurnk/plurnk-provider-native": { name: "@plurnk/plurnk-provider-native", plurnk: { kind: "provider", name: "native" } },

package/src/discover.ts

@@ -1,8 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import Meta from "@plurnk/plurnk-meta";
+import type {
+    PackageAttributions,
+    PluginAttribution,
+    PluginAttributionDeclaration,
+} from "@plurnk/plurnk-meta";
 
-// Scope-agnostic discovery of installed AI SDK provider packages (SPEC §5).
+// Scope-agnostic discovery of installed AI SDK provider packages
+// ({§plugin-family-kind}).
 // Parallel to @plurnk/plurnk-execs' discover(): scan every installed package
 // under `<cwd>/node_modules` — scoped (`@scope/name`) and unscoped — and keep
 // the ones declaring `plurnk.kind === "provider"`. Scope-agnostic so a THIRD
@@ -16,7 +22,7 @@ import Meta from "@plurnk/plurnk-meta";
 //
 // Cataloged and operator-declared providers resolve before this scan.
 //
-// Host plugin trust gate (PLURNK_PLUGINS_TRUSTED_ONLY, #15 / plurnk-service#229)
+// {§plugin-trust-boundary} Host plugin trust gate (PLURNK_PLUGINS_TRUSTED_ONLY)
 // — enforced uniformly across the four scope-agnostic families. An untrusted
 // package is discovered-but-declined (recorded in `skipped`, never registered,
 // never thrown), so the consumer can name it in a precise error.
@@ -31,12 +37,9 @@ export type DiscoverOptions = {
 export type Discovery = {
     registry: Map<string, string>; // trusted providers, eligible to instantiate
     skipped: Map<string, string>;  // declined by the trust gate (untrusted)
-    // name → raw `plurnk.attribution` (string | string[]) declared by a registered
-    // provider package's manifest, for crediting the provider's author (#21,
-    // plurnk-service#249). Surfaced verbatim — the consumer applies the reservation
-    // policy (`@plurnk/` tags only from `@plurnk/`-scoped packages). Absent for
-    // providers that declare none.
+    // Published name-keyed projection retained for 1.x consumers.
     attributions: Map<string, string | string[]>;
+    packageAttributions: PackageAttributions;
 };
 
 
@@ -46,7 +49,8 @@ export const discover = async (options: DiscoverOptions = {}): Promise<Discovery
 
     const registry = new Map<string, string>();
     const skipped = new Map<string, string>();
-    const attributions = new Map<string, string | string[]>();
+    const attributions = new Map<string, PluginAttributionDeclaration>();
+    const packageAttributions = new Map<string, PluginAttribution>();
     for (const dir of dirs) {
         const info = await readProviderInfo(dir);
         if (info === null) continue;
@@ -61,10 +65,13 @@ export const discover = async (options: DiscoverOptions = {}): Promise<Discovery
                 + `${existing} and ${info.packageName}`,
             );
         }
+        const tags = Meta.normalizeAttribution(info.attribution, info.packageName);
         registry.set(info.name, info.packageName);
-        if (info.attribution !== undefined) attributions.set(info.name, info.attribution);
+        const attribution = attributionProjection(info.attribution, tags);
+        if (attribution !== undefined) attributions.set(info.name, attribution);
+        if (tags.length > 0) packageAttributions.set(info.packageName, tags);
     }
-    return { registry, skipped, attributions };
+    return { registry, skipped, attributions, packageAttributions };
 };
 
 // Enumerate every installed package directory — scoped and unscoped — under
@@ -74,11 +81,10 @@ const defaultPackageDirs = async (cwd: string): Promise<string[]> => {
     return (await Meta.packageDirs(nm)).map((c) => c.dir).toSorted();
 };
 
-// One { name, packageName, attribution? } for a provider package, or null for
-// anything that isn't one (missing/invalid package.json, no plurnk block, wrong
-// kind, no name). `attribution` mirrors `plurnk.attribution` when it's a string
-// or string[] (anything else is ignored).
-type ProviderInfo = { name: string; packageName: string; attribution?: string | string[] };
+// One inert manifest record for a provider package, or null for anything that
+// isn't one. Attribution remains unknown until trust admission, then the shared
+// {§plugin-attribution} boundary validates it.
+type ProviderInfo = { name: string; packageName: string; attribution: unknown };
 
 const readProviderInfo = async (dir: string): Promise<ProviderInfo | null> => {
     let raw: string;
@@ -98,12 +104,16 @@ const readProviderInfo = async (dir: string): Promise<ProviderInfo | null> => {
     const plurnk = record.plurnk;
     if (typeof plurnk !== "object" || plurnk === null) return null;
     const plurnkRec = plurnk as Record<string, unknown>;
-    if (plurnkRec.kind !== "provider") return null;
+    if (!Meta.declaresKind(plurnkRec, "provider")) return null;
     if (typeof plurnkRec.name !== "string" || plurnkRec.name === "") return null;
     if (typeof record.name !== "string" || record.name === "") return null;
-    const attr = plurnkRec.attribution;
-    const attribution = typeof attr === "string" ? attr
-        : Array.isArray(attr) && attr.every((x) => typeof x === "string") ? (attr as string[])
-        : undefined;
-    return { name: plurnkRec.name, packageName: record.name, attribution };
+    return { name: plurnkRec.name, packageName: record.name, attribution: plurnkRec.attribution };
+};
+
+const attributionProjection = (
+    raw: unknown,
+    tags: PluginAttribution,
+): PluginAttributionDeclaration | undefined => {
+    if (raw === undefined || raw === null) return undefined;
+    return typeof raw === "string" ? raw : [...tags];
 };