@namzu/sdk 27.1.0 → 29.0.0

package/dist/prompt/contributions.d.ts

@@ -0,0 +1,138 @@
+import type { AgentRuntimeContext } from '../types/agent/base.js';
+import type { Skill } from '../types/skills/index.js';
+/**
+ * A seam for putting something in the system prompt.
+ *
+ * The prompt was closed. `PromptBuilder` assembled a fixed list — base
+ * prompt, persona or system prompt, skills, tool section, tier guidance,
+ * environment — and every one of those was a branch written into the
+ * builder. A capability that needed the model to know something (web tools
+ * and their citation rules, a plugin's conventions, a host's house style)
+ * had exactly two options: convince somebody to add a branch, or splice it
+ * into `systemPrompt` and lose whatever was there.
+ *
+ * Skills is the first contributor through this seam, and deliberately so:
+ * it was already a special case in four places in the builder, so making it
+ * one is the smallest change that proves the seam carries a real one rather
+ * than a shape invented to fit.
+ */
+export interface PromptContributionContext {
+    readonly workingDirectory?: string;
+    readonly runtimeContext?: AgentRuntimeContext;
+    readonly skills?: readonly Skill[];
+    /** The tools this turn may call, if the turn was narrowed. */
+    readonly allowedTools?: readonly string[];
+    /**
+     * Which iteration this is, 1-based — present only for `turn`.
+     *
+     * Absent for `static` and `dynamic`, and that absence is the type
+     * saying what the placement means: a contribution that needs to know
+     * which turn it is cannot be part of a prompt assembled once and
+     * cached.
+     */
+    readonly iteration?: number;
+}
+/**
+ * Which half of the prompt this lands in.
+ *
+ * Not cosmetic, and the wrong answer is expensive in a way nothing reports.
+ * `static` is the segment the prompt cache keeps and a provider caches
+ * across turns; `dynamic` is re-sent every iteration. A contributor whose
+ * text varies per turn but declares `static` either invalidates the cached
+ * prefix on every iteration — paying full price for a cache that never
+ * hits — or, worse, gets served the first turn's text forever.
+ *
+ * The rule: `static` iff the output depends only on things that cannot
+ * change inside one run.
+ */
+export type PromptPlacement = 'static' | 'dynamic' | 'turn';
+/**
+ * `turn` is a third thing, not a looser `dynamic`.
+ *
+ * `static` and `dynamic` are both parts of the SYSTEM PROMPT: assembled
+ * once per request, sent as system messages, and — for `static` — cached by
+ * the provider across turns. `turn` is not in the system prompt at all. It
+ * rides the ephemeral trailing message that a step's guidance, its skills
+ * and the approval-policy notice already use: appended to the request,
+ * never pushed onto the run's history, and gone the moment the request is
+ * sent.
+ *
+ * That is the placement for state that changes DURING a run — a budget
+ * running down, a queue draining, a policy that just moved. Putting such a
+ * thing in `static` serves the first iteration's value forever; putting it
+ * in `dynamic` re-sends it in a position the model reads as part of its
+ * standing instructions rather than as a status.
+ *
+ * The cost of `turn` is real and worth stating: every iteration pays for it
+ * in tokens, and it lands after the cached prefix so it cannot be cached.
+ * The approval-policy notice is the shape to copy — it returns text only
+ * when something actually changed, and `null` on every other turn.
+ */
+export interface PromptContribution {
+    /**
+     * Stable and unique. Registration refuses a duplicate rather than
+     * letting the second silently win, because "my guidance stopped
+     * appearing" is the least debuggable failure this registry could have.
+     */
+    readonly id: string;
+    readonly placement: PromptPlacement;
+    /** `null` for "nothing to say this time", which is not an error. */
+    render(context: PromptContributionContext): string | null;
+}
+/** Two contributions claiming one id. */
+export declare class PromptContributionCollisionError extends Error {
+    readonly details: {
+        id: string;
+    };
+    constructor(details: {
+        id: string;
+    });
+}
+/**
+ * What goes in the prompt beyond what the builder knows about.
+ *
+ * Registration order is the rendering order, and that is the contract: an
+ * ordering derived from something else — priority numbers, id sort — would
+ * have every contributor arguing about a number, and the prompt is read
+ * top to bottom by a model that weights early text more.
+ */
+export declare class PromptContributionRegistry {
+    private readonly byId;
+    register(contribution: PromptContribution): void;
+    /** Replace one already registered, for a host that owns both. */
+    replace(contribution: PromptContribution): void;
+    has(id: string): boolean;
+    /** In registration order. */
+    list(): readonly PromptContribution[];
+    /**
+     * Every contribution for one placement, rendered, with the empty ones
+     * dropped.
+     *
+     * Dropping `null` here rather than at each call site is the point: a
+     * contributor that has nothing to say this turn must not leave a blank
+     * section behind, and four separate `if (x) parts.push(x)` sites is four
+     * chances for one of them to forget.
+     */
+    render(placement: PromptPlacement, context: PromptContributionContext): readonly string[];
+}
+/** The id the built-in skills contribution registers under. */
+export declare const SKILLS_CONTRIBUTION_ID = "namzu.skills";
+/**
+ * Skills, as a contribution.
+ *
+ * `static`, because a run's skill set is fixed for the run — a STEP's
+ * skills are a different thing entirely and ride the ephemeral trailing
+ * system message, which is what keeps them out of the cached prefix.
+ *
+ * The persona path does not use this. `assembleSystemPrompt(persona,
+ * skills)` renders skills INSIDE the persona's own section ordering, which
+ * is a persona-assembler decision about where skills belong relative to
+ * constraints and output discipline. Moving it out here would silently
+ * reorder every persona-driven prompt in the estate to buy uniformity
+ * nobody asked for. So this contribution serves the branches that render
+ * skills standalone, and the persona branch keeps its own — stated here
+ * because two renderers for one concept is exactly the kind of thing that
+ * looks like an oversight later.
+ */
+export declare const skillsContribution: PromptContribution;
+//# sourceMappingURL=contributions.d.ts.map

package/dist/prompt/contributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contributions.d.ts","sourceRoot":"","sources":["../../src/prompt/contributions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,yBAAyB;IACzC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAA;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAA;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACzC;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;IACnC,oEAAoE;IACpE,MAAM,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,GAAG,IAAI,CAAA;CACzD;AAED,yCAAyC;AACzC,qBAAa,gCAAiC,SAAQ,KAAK;IAC1D,QAAQ,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;gBAEpB,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE;CAKnC;AAED;;;;;;;GAOG;AACH,qBAAa,0BAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAwC;IAE7D,QAAQ,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAOhD,iEAAiE;IACjE,OAAO,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAI/C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,6BAA6B;IAC7B,IAAI,IAAI,SAAS,kBAAkB,EAAE;IAIrC;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,yBAAyB,GAAG,SAAS,MAAM,EAAE;CAMzF;AAED,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,iBAAiB,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAIhC,CAAA"}

package/dist/prompt/contributions.js

@@ -0,0 +1,78 @@
+import { renderSkillsSection } from '../persona/assembler.js';
+/** Two contributions claiming one id. */
+export class PromptContributionCollisionError extends Error {
+    details;
+    constructor(details) {
+        super(`A prompt contribution with id "${details.id}" is already registered.`);
+        this.name = 'PromptContributionCollisionError';
+        this.details = details;
+    }
+}
+/**
+ * What goes in the prompt beyond what the builder knows about.
+ *
+ * Registration order is the rendering order, and that is the contract: an
+ * ordering derived from something else — priority numbers, id sort — would
+ * have every contributor arguing about a number, and the prompt is read
+ * top to bottom by a model that weights early text more.
+ */
+export class PromptContributionRegistry {
+    byId = new Map();
+    register(contribution) {
+        if (this.byId.has(contribution.id)) {
+            throw new PromptContributionCollisionError({ id: contribution.id });
+        }
+        this.byId.set(contribution.id, contribution);
+    }
+    /** Replace one already registered, for a host that owns both. */
+    replace(contribution) {
+        this.byId.set(contribution.id, contribution);
+    }
+    has(id) {
+        return this.byId.has(id);
+    }
+    /** In registration order. */
+    list() {
+        return [...this.byId.values()];
+    }
+    /**
+     * Every contribution for one placement, rendered, with the empty ones
+     * dropped.
+     *
+     * Dropping `null` here rather than at each call site is the point: a
+     * contributor that has nothing to say this turn must not leave a blank
+     * section behind, and four separate `if (x) parts.push(x)` sites is four
+     * chances for one of them to forget.
+     */
+    render(placement, context) {
+        return this.list()
+            .filter((contribution) => contribution.placement === placement)
+            .map((contribution) => contribution.render(context))
+            .filter((text) => typeof text === 'string' && text.trim().length > 0);
+    }
+}
+/** The id the built-in skills contribution registers under. */
+export const SKILLS_CONTRIBUTION_ID = 'namzu.skills';
+/**
+ * Skills, as a contribution.
+ *
+ * `static`, because a run's skill set is fixed for the run — a STEP's
+ * skills are a different thing entirely and ride the ephemeral trailing
+ * system message, which is what keeps them out of the cached prefix.
+ *
+ * The persona path does not use this. `assembleSystemPrompt(persona,
+ * skills)` renders skills INSIDE the persona's own section ordering, which
+ * is a persona-assembler decision about where skills belong relative to
+ * constraints and output discipline. Moving it out here would silently
+ * reorder every persona-driven prompt in the estate to buy uniformity
+ * nobody asked for. So this contribution serves the branches that render
+ * skills standalone, and the persona branch keeps its own — stated here
+ * because two renderers for one concept is exactly the kind of thing that
+ * looks like an oversight later.
+ */
+export const skillsContribution = {
+    id: SKILLS_CONTRIBUTION_ID,
+    placement: 'static',
+    render: (context) => renderSkillsSection(context.skills ? [...context.skills] : undefined),
+};
+//# sourceMappingURL=contributions.js.map

package/dist/prompt/contributions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contributions.js","sourceRoot":"","sources":["../../src/prompt/contributions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAwF7D,yCAAyC;AACzC,MAAM,OAAO,gCAAiC,SAAQ,KAAK;IACjD,OAAO,CAAgB;IAEhC,YAAY,OAAuB;QAClC,KAAK,CAAC,kCAAkC,OAAO,CAAC,EAAE,0BAA0B,CAAC,CAAA;QAC7E,IAAI,CAAC,IAAI,GAAG,kCAAkC,CAAA;QAC9C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACvB,CAAC;CACD;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,0BAA0B;IACrB,IAAI,GAAG,IAAI,GAAG,EAA8B,CAAA;IAE7D,QAAQ,CAAC,YAAgC;QACxC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,gCAAgC,CAAC,EAAE,EAAE,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,CAAA;QACpE,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,EAAE,YAAY,CAAC,CAAA;IAC7C,CAAC;IAED,iEAAiE;IACjE,OAAO,CAAC,YAAgC;QACvC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,EAAE,YAAY,CAAC,CAAA;IAC7C,CAAC;IAED,GAAG,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACzB,CAAC;IAED,6BAA6B;IAC7B,IAAI;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAA;IAC/B,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,SAA0B,EAAE,OAAkC;QACpE,OAAO,IAAI,CAAC,IAAI,EAAE;aAChB,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,KAAK,SAAS,CAAC;aAC9D,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aACnD,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IACvF,CAAC;CACD;AAED,+DAA+D;AAC/D,MAAM,CAAC,MAAM,sBAAsB,GAAG,cAAc,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACrD,EAAE,EAAE,sBAAsB;IAC1B,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;CAC1F,CAAA"}

package/dist/prompt/index.d.ts

@@ -0,0 +1,3 @@
+export { PromptContributionCollisionError, PromptContributionRegistry, SKILLS_CONTRIBUTION_ID, skillsContribution, } from './contributions.js';
+export type { PromptContribution, PromptContributionContext, PromptPlacement, } from './contributions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/prompt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompt/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACN,gCAAgC,EAChC,0BAA0B,EAC1B,sBAAsB,EACtB,kBAAkB,GAClB,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACX,kBAAkB,EAClB,yBAAyB,EACzB,eAAe,GACf,MAAM,oBAAoB,CAAA"}

package/dist/prompt/index.js

@@ -0,0 +1,6 @@
+// A seam for putting something in the system prompt. The prompt was closed:
+// every section was a branch inside `PromptBuilder`, so a capability that
+// needed the model to know something had to argue for a branch or splice
+// into `systemPrompt` and lose whatever was there.
+export { PromptContributionCollisionError, PromptContributionRegistry, SKILLS_CONTRIBUTION_ID, skillsContribution, } from './contributions.js';
+//# sourceMappingURL=index.js.map

package/dist/prompt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompt/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,0EAA0E;AAC1E,yEAAyE;AACzE,mDAAmD;AACnD,OAAO,EACN,gCAAgC,EAChC,0BAA0B,EAC1B,sBAAsB,EACtB,kBAAkB,GAClB,MAAM,oBAAoB,CAAA"}

package/dist/provider/attribution.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Who is calling, said once.
+ *
+ * No driver identified this kernel to a provider. The only user-agent
+ * anywhere was on one OAuth code path, set so a token-exchange endpoint
+ * would accept the request — that is load-bearing impersonation, not
+ * attribution, and it must not be touched.
+ *
+ * What attribution buys is not vanity. A provider reading its own logs can
+ * tell a kernel's traffic from a browser's; a rate-limit or an abuse
+ * investigation lands on the right party; and a driver bug reported by a
+ * vendor arrives with something to search for. None of that is possible
+ * from an unlabelled request.
+ *
+ * ## One header, and only one
+ *
+ * Every additional header is a thing a proxy may strip, a vendor may
+ * reject, and a reader has to reconcile. The helper returns exactly one
+ * key and a test asserts the count — a driver wanting to send something of
+ * its own sends it at its own seam rather than growing this.
+ */
+export interface AppIdentity {
+    /** Product name, as it should appear in a vendor's logs. */
+    readonly product: string;
+    /** Version of the product. Read, never hand-copied. */
+    readonly version: string;
+    /** Where a vendor can find out what this is. */
+    readonly url: string;
+}
+/**
+ * `version` comes from `VERSION`, which is read from the package manifest
+ * — a hand-copied literal here would be wrong from the first release after
+ * somebody forgot it, and wrong in the one place a vendor is reading to
+ * decide which build has the bug.
+ */
+export declare const NAMZU_APP_IDENTITY: AppIdentity;
+/**
+ * The single header a driver merges at its own seam.
+ *
+ * Pure, and takes the identity as an argument, so a host embedding this
+ * kernel in its own product can say so — and so a driver cannot hardcode
+ * the constant and quietly ignore what the host asked for.
+ */
+export declare function attributionHeaders(identity?: AppIdentity): Record<string, string>;
+//# sourceMappingURL=attribution.d.ts.map

package/dist/provider/attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution.d.ts","sourceRoot":"","sources":["../../src/provider/attribution.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,WAAW;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAIhC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,QAAQ,GAAE,WAAgC,GACxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAExB"}

package/dist/provider/attribution.js

@@ -0,0 +1,23 @@
+import { VERSION } from '../version.js';
+/**
+ * `version` comes from `VERSION`, which is read from the package manifest
+ * — a hand-copied literal here would be wrong from the first release after
+ * somebody forgot it, and wrong in the one place a vendor is reading to
+ * decide which build has the bug.
+ */
+export const NAMZU_APP_IDENTITY = {
+    product: 'namzu',
+    version: VERSION,
+    url: 'https://github.com/cogitave/namzu',
+};
+/**
+ * The single header a driver merges at its own seam.
+ *
+ * Pure, and takes the identity as an argument, so a host embedding this
+ * kernel in its own product can say so — and so a driver cannot hardcode
+ * the constant and quietly ignore what the host asked for.
+ */
+export function attributionHeaders(identity = NAMZU_APP_IDENTITY) {
+    return { 'User-Agent': `${identity.product}/${identity.version} (+${identity.url})` };
+}
+//# sourceMappingURL=attribution.js.map

package/dist/provider/attribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution.js","sourceRoot":"","sources":["../../src/provider/attribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAiCvC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAgB;IAC9C,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE,OAAO;IAChB,GAAG,EAAE,mCAAmC;CACxC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CACjC,WAAwB,kBAAkB;IAE1C,OAAO,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC,OAAO,IAAI,QAAQ,CAAC,OAAO,MAAM,QAAQ,CAAC,GAAG,GAAG,EAAE,CAAA;AACtF,CAAC"}

package/dist/provider/{collect.d.ts → collect-chat-completion.d.ts}

@@ -8,7 +8,7 @@ import type { StreamChunk } from '../types/provider/stream.js';
  * four internal callers that genuinely need the aggregated view (advisory
  * executor, RouterAgent's deterministic routing decision, compaction's
  * verifier, the instrumentation wrapper) replace `provider.chat(p)` with
- * `collect(provider.chatStream(p))`.
+ * `collectChatCompletion(provider.chatStream(p))`.
  *
  * Behaviour matches the pre-removal `chat()` contract:
  * - text content is concatenated in delta order;
@@ -21,5 +21,5 @@ import type { StreamChunk } from '../types/provider/stream.js';
  * The orchestrator does NOT call this helper — it consumes the stream
  * directly so it can emit per-delta `RunEvent`s.
  */
-export declare function collect(stream: AsyncIterable<StreamChunk>): Promise<ChatCompletionResponse>;
-//# sourceMappingURL=collect.d.ts.map
+export declare function collectChatCompletion(stream: AsyncIterable<StreamChunk>): Promise<ChatCompletionResponse>;
+//# sourceMappingURL=collect-chat-completion.d.ts.map

package/dist/provider/collect-chat-completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-chat-completion.d.ts","sourceRoot":"","sources":["../../src/provider/collect-chat-completion.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CAC1C,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,GAChC,OAAO,CAAC,sBAAsB,CAAC,CA8DjC"}

package/dist/provider/{collect.js → collect-chat-completion.js}

@@ -7,7 +7,7 @@ import { mergeTokenUsage } from '../types/common/index.js';
  * four internal callers that genuinely need the aggregated view (advisory
  * executor, RouterAgent's deterministic routing decision, compaction's
  * verifier, the instrumentation wrapper) replace `provider.chat(p)` with
- * `collect(provider.chatStream(p))`.
+ * `collectChatCompletion(provider.chatStream(p))`.
  *
  * Behaviour matches the pre-removal `chat()` contract:
  * - text content is concatenated in delta order;
@@ -20,7 +20,7 @@ import { mergeTokenUsage } from '../types/common/index.js';
  * The orchestrator does NOT call this helper — it consumes the stream
  * directly so it can emit per-delta `RunEvent`s.
  */
-export async function collect(stream) {
+export async function collectChatCompletion(stream) {
     let id = '';
     const model = '';
     let content = '';
@@ -82,4 +82,4 @@ export async function collect(stream) {
         usage,
     };
 }
-//# sourceMappingURL=collect.js.map
+//# sourceMappingURL=collect-chat-completion.js.map

package/dist/provider/collect-chat-completion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-chat-completion.js","sourceRoot":"","sources":["../../src/provider/collect-chat-completion.ts"],"names":[],"mappings":"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"}

package/dist/provider/conformance.d.ts

@@ -0,0 +1,93 @@
+import type { ConformanceDescribe, ConformanceExpect, ConformanceIt } from '../store/run/conformance.js';
+import type { LLMProvider } from '../types/provider/interface.js';
+import type { ProviderRetryConfig } from './retry.js';
+/**
+ * The driver contract, as a suite every driver package runs.
+ *
+ * Seven packages implement `LLMProvider` and there was nowhere to write a
+ * rule binding all of them. Each carried a hand-written error-taxonomy
+ * test covering the same ground differently, and every provider finding in
+ * the audit was a behaviour present in exactly ONE driver and absent from
+ * the other six — which is what you get when a contract lives in seven
+ * copies of a test rather than in one place. Nothing failed when an eighth
+ * package appeared implementing none of it.
+ *
+ * The mechanism already existed for a different interface: the checkpoint
+ * store publishes its contract at `@namzu/sdk/testing` and takes its
+ * runner as an argument. This copies that shape exactly, for the same two
+ * reasons — the SDK gains no test dependency from publishing a suite, and
+ * a caller can pass a RECORDING `describe`/`it` and run the whole contract
+ * as ordinary code, which is how a deliberately wrong driver is shown to
+ * fail it.
+ *
+ * ## What is in it, and what is deliberately not
+ *
+ * Seeded only with rules that pass for every driver today. A suite that
+ * ships red is a suite somebody switches off in its first week, and the
+ * point of it is to hold the line while the four known gaps are closed one
+ * at a time — each of which adds a rule here in the commit that fixes it.
+ *
+ * ## Consuming it
+ *
+ * ```typescript
+ * import { describe, expect, it } from 'vitest'
+ * import { defineProviderDriverConformance } from '@namzu/sdk/testing'
+ *
+ * defineProviderDriverConformance({
+ *   describe, it, expect,
+ *   label: 'anthropic',
+ *   registryType: 'anthropic',
+ *   makeProvider: () => new AnthropicProvider({ apiKey: 'test' }),
+ * })
+ * ```
+ */
+/** The contract revision a driver declares itself written against. */
+export declare const PROVIDER_DRIVER_CONTRACT_VERSION = 1;
+export interface ProviderDriverConformanceOptions {
+    readonly describe: ConformanceDescribe;
+    readonly it: ConformanceIt;
+    readonly expect: ConformanceExpect;
+    /**
+     * The string this driver is registered under. Asserted to equal `id`,
+     * because the two are used interchangeably at call sites — a chain
+     * member names one and a `ProviderRegistry` lookup uses the other — and
+     * a driver where they differ resolves for some callers and not others.
+     */
+    readonly registryType: string;
+    /**
+     * Built once per case. No case may depend on another's state, and a
+     * driver that holds a connection gets a fresh one rather than a shared
+     * instance the suite would then have to clean.
+     */
+    readonly makeProvider: () => LLMProvider | Promise<LLMProvider>;
+    /**
+     * What this driver declares as its retry defaults, restated here.
+     *
+     * REQUIRED, and required as a value rather than inferred from the
+     * driver, so a new package cannot skip the decision by not thinking
+     * about it. `undefined` is a legitimate answer — it means the generic
+     * default suits this vendor — but it has to be written down, which is
+     * the difference between a decision and an omission.
+     */
+    readonly retryDefaults: Partial<ProviderRetryConfig> | undefined;
+    /**
+     * Whether this driver identifies the kernel to its vendor, and if not
+     * why not.
+     *
+     * REQUIRED for the same reason `retryDefaults` is: a package that never
+     * decided should not typecheck. `'unsupported'` is a legitimate answer
+     * — one vendor's client speaks a websocket protocol with no header seam
+     * — but it has to carry a reason, so the next reader learns whether it
+     * is impossible or merely undone.
+     */
+    readonly attribution: {
+        kind: 'header';
+    } | {
+        kind: 'unsupported';
+        reason: string;
+    };
+    /** Names the driver in test output. Defaults to `provider driver`. */
+    readonly label?: string;
+}
+export declare function defineProviderDriverConformance(options: ProviderDriverConformanceOptions): void;
+//# sourceMappingURL=conformance.d.ts.map

package/dist/provider/conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/provider/conformance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,MAAM,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,sEAAsE;AACtE,eAAO,MAAM,gCAAgC,IAAI,CAAA;AAEjD,MAAM,WAAW,gCAAgC;IAChD,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAC/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;IAChE;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAClF,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI,CA8F/F"}

package/dist/provider/conformance.js

@@ -0,0 +1,124 @@
+/**
+ * The driver contract, as a suite every driver package runs.
+ *
+ * Seven packages implement `LLMProvider` and there was nowhere to write a
+ * rule binding all of them. Each carried a hand-written error-taxonomy
+ * test covering the same ground differently, and every provider finding in
+ * the audit was a behaviour present in exactly ONE driver and absent from
+ * the other six — which is what you get when a contract lives in seven
+ * copies of a test rather than in one place. Nothing failed when an eighth
+ * package appeared implementing none of it.
+ *
+ * The mechanism already existed for a different interface: the checkpoint
+ * store publishes its contract at `@namzu/sdk/testing` and takes its
+ * runner as an argument. This copies that shape exactly, for the same two
+ * reasons — the SDK gains no test dependency from publishing a suite, and
+ * a caller can pass a RECORDING `describe`/`it` and run the whole contract
+ * as ordinary code, which is how a deliberately wrong driver is shown to
+ * fail it.
+ *
+ * ## What is in it, and what is deliberately not
+ *
+ * Seeded only with rules that pass for every driver today. A suite that
+ * ships red is a suite somebody switches off in its first week, and the
+ * point of it is to hold the line while the four known gaps are closed one
+ * at a time — each of which adds a rule here in the commit that fixes it.
+ *
+ * ## Consuming it
+ *
+ * ```typescript
+ * import { describe, expect, it } from 'vitest'
+ * import { defineProviderDriverConformance } from '@namzu/sdk/testing'
+ *
+ * defineProviderDriverConformance({
+ *   describe, it, expect,
+ *   label: 'anthropic',
+ *   registryType: 'anthropic',
+ *   makeProvider: () => new AnthropicProvider({ apiKey: 'test' }),
+ * })
+ * ```
+ */
+/** The contract revision a driver declares itself written against. */
+export const PROVIDER_DRIVER_CONTRACT_VERSION = 1;
+export function defineProviderDriverConformance(options) {
+    const { describe, it, expect, makeProvider, registryType } = options;
+    const label = options.label ?? 'provider driver';
+    describe(`${label} — driver contract v${PROVIDER_DRIVER_CONTRACT_VERSION}`, () => {
+        it('has a non-empty id and name', async () => {
+            // Both reach a human or a log line. An empty one produces a
+            // provider-chain entry that names nothing, which is worse than a
+            // wrong name because there is nothing to search for.
+            const provider = await makeProvider();
+            expect(typeof provider.id).toBe('string');
+            expect(provider.id.length > 0).toBe(true);
+            expect(typeof provider.name).toBe('string');
+            expect(provider.name.length > 0).toBe(true);
+        });
+        it('has an id equal to the string it is registered under', async () => {
+            // A chain member names the registry type; a lookup uses `id`. A
+            // driver where they differ resolves through one path and not the
+            // other, and the failure appears at whichever call site the host
+            // happens to reach second.
+            const provider = await makeProvider();
+            expect(provider.id).toBe(registryType);
+        });
+        it('exposes chatStream as a function', async () => {
+            // The single entry point. Asserted because a driver can satisfy
+            // the type by declaring it and still ship an object literal that
+            // forgot it — the interface is structural.
+            const provider = await makeProvider();
+            expect(typeof provider.chatStream).toBe('function');
+        });
+        it('declares capabilities honestly or not at all', async () => {
+            // Optional BY DESIGN: an absent declaration resolves to the
+            // permissive default, which is the behaviour every driver had
+            // before the field existed. What is not allowed is a declaration
+            // that is present and not a capability record — that reaches the
+            // runtime as "supports nothing" and silently strips tool surfaces.
+            const provider = await makeProvider();
+            if (provider.capabilities === undefined)
+                return;
+            expect(typeof provider.capabilities.supportsTools).toBe('boolean');
+            expect(typeof provider.capabilities.supportsStreaming).toBe('boolean');
+            expect(typeof provider.capabilities.supportsFunctionCalling).toBe('boolean');
+        });
+        // NOT A RULE HERE, and the reason is worth keeping.
+        //
+        // NZ-PROV-05 makes `contextWindow`/`maxOutputTokens` optional so a
+        // driver stops writing `0` for "I do not know" — zero is not a
+        // window, and it reads to every consumer as a measurement of a model
+        // that can hold nothing.
+        //
+        // The obvious place to enforce that is here, reading `listModels`.
+        // It was here, and it was worse than nothing twice over. For every
+        // in-tree driver `listModels` needs a live service, so the rule
+        // returned early and asserted NOTHING in CI — verified by putting a
+        // zero back and watching the driver's run stay green. And lmstudio's
+        // does not throw, it HANGS: the rule timed out that package's whole
+        // conformance run. A check that cannot fail, attached to a suite it
+        // can take down.
+        //
+        // The reintroduction of a literal zero is caught by a source scan in
+        // `provider/__tests__/conformance-fails-a-wrong-driver.test.ts`,
+        // which depends on reaching nothing.
+        it('declares the retry defaults its conformance run says it does', async () => {
+            // The option above forces the decision; this asserts the answer is
+            // TRUE of the driver. Without it a package could declare one thing
+            // in its test and ship another, which is the same gap as no
+            // declaration at all with an extra place to look.
+            const provider = await makeProvider();
+            expect(JSON.stringify(provider.retryDefaults ?? null)).toBe(JSON.stringify(options.retryDefaults ?? null));
+        });
+        it('builds a second instance independent of the first', async () => {
+            // The property the suite itself relies on, and one a driver can
+            // break by caching a client on the module. Every case above calls
+            // `makeProvider` again; if that returned a shared object, a
+            // driver's state would leak between cases and this suite would
+            // report on whichever one ran first.
+            const a = await makeProvider();
+            const b = await makeProvider();
+            expect(a === b).toBe(false);
+        });
+    });
+}
+//# sourceMappingURL=conformance.js.map

package/dist/provider/conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.js","sourceRoot":"","sources":["../../src/provider/conformance.ts"],"names":[],"mappings":"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"}