@graphorin/provider 0.5.0

package/dist/middleware/with-tracing.js

@@ -0,0 +1,55 @@
+import { defineProviderMiddleware } from "./compose.js";
+
+//#region src/middleware/with-tracing.ts
+/**
+* @stable
+*/
+const withTracing = defineProviderMiddleware({
+	kind: "withTracing",
+	factory: (opts) => {
+		return (next) => ({
+			name: next.name,
+			modelId: next.modelId,
+			capabilities: next.capabilities,
+			...next.acceptsSensitivity !== void 0 ? { acceptsSensitivity: next.acceptsSensitivity } : {},
+			stream(req) {
+				if (opts.tracer === void 0) return next.stream(req);
+				return tracedStream(opts.tracer, next, req);
+			},
+			async generate(req) {
+				if (opts.tracer === void 0) return next.generate(req);
+				return opts.tracer.span({
+					type: "provider.generate",
+					attrs: {
+						"graphorin.provider.id": next.name,
+						"graphorin.provider.model": next.modelId
+					}
+				}, async () => next.generate(req));
+			},
+			...next.countTokens ? { countTokens: next.countTokens.bind(next) } : {}
+		});
+	}
+});
+async function* tracedStream(tracer, next, req) {
+	const span = tracer.startSpan({
+		type: "provider.stream",
+		attrs: {
+			"graphorin.provider.id": next.name,
+			"graphorin.provider.model": next.modelId
+		}
+	});
+	try {
+		for await (const event of next.stream(req)) yield event;
+		span.setStatus("ok");
+	} catch (err) {
+		span.recordException(err);
+		span.setStatus("error", err.message);
+		throw err;
+	} finally {
+		span.end();
+	}
+}
+
+//#endregion
+export { withTracing };
+//# sourceMappingURL=with-tracing.js.map

package/dist/middleware/with-tracing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-tracing.js","names":[],"sources":["../../src/middleware/with-tracing.ts"],"sourcesContent":["/**\n * `withTracing` — outermost middleware. Wraps every `provider.stream`\n * / `provider.generate` call in a Graphorin OTel-shaped span so the\n * span captures retry decisions, rate-limit waits, and the underlying\n * provider call as one logical unit.\n *\n * The middleware accepts any object that exposes the\n * {@link Tracer} contract from `@graphorin/core/contracts`. Tests pass\n * a `NOOP_TRACER`-shaped stub; production wires the real Graphorin\n * tracer from `@graphorin/observability`.\n *\n * @packageDocumentation\n */\n\nimport type { Provider, Tracer } from '@graphorin/core';\n\nimport { defineProviderMiddleware } from './compose.js';\n\n/**\n * Options for {@link withTracing}.\n *\n * @stable\n */\nexport interface WithTracingOptions {\n  /** Tracer instance. Defaults to a no-op tracer if unset. */\n  readonly tracer?: Tracer;\n}\n\n/**\n * @stable\n */\nexport const withTracing = defineProviderMiddleware<WithTracingOptions>({\n  kind: 'withTracing',\n  factory: (opts: WithTracingOptions) => {\n    return (next: Provider): Provider => ({\n      name: next.name,\n      modelId: next.modelId,\n      capabilities: next.capabilities,\n      ...(next.acceptsSensitivity !== undefined\n        ? { acceptsSensitivity: next.acceptsSensitivity }\n        : {}),\n      stream(req) {\n        if (opts.tracer === undefined) return next.stream(req);\n        return tracedStream(opts.tracer, next, req);\n      },\n      async generate(req) {\n        if (opts.tracer === undefined) return next.generate(req);\n        return opts.tracer.span(\n          {\n            type: 'provider.generate' as const,\n            attrs: {\n              'graphorin.provider.id': next.name,\n              'graphorin.provider.model': next.modelId,\n            },\n          },\n          async () => next.generate(req),\n        );\n      },\n      ...(next.countTokens ? { countTokens: next.countTokens.bind(next) } : {}),\n    });\n  },\n});\n\nasync function* tracedStream(\n  tracer: Tracer,\n  next: Provider,\n  req: import('@graphorin/core').ProviderRequest,\n): AsyncIterable<import('@graphorin/core').ProviderEvent> {\n  const span = tracer.startSpan({\n    type: 'provider.stream' as const,\n    attrs: {\n      'graphorin.provider.id': next.name,\n      'graphorin.provider.model': next.modelId,\n    },\n  });\n  try {\n    for await (const event of next.stream(req)) {\n      yield event;\n    }\n    span.setStatus('ok');\n  } catch (err) {\n    span.recordException(err);\n    span.setStatus('error', (err as Error).message);\n    throw err;\n  } finally {\n    // PS-7: a consumer `break`/early-return injects a generator `return` at the\n    // `yield`, skipping both the success and catch paths. Ending the span in\n    // `finally` guarantees it is closed exactly once on every exit — normal\n    // completion, error, or early abort (which leaves the status unset).\n    span.end();\n  }\n}\n"],"mappings":";;;;;;AA+BA,MAAa,cAAc,yBAA6C;CACtE,MAAM;CACN,UAAU,SAA6B;AACrC,UAAQ,UAA8B;GACpC,MAAM,KAAK;GACX,SAAS,KAAK;GACd,cAAc,KAAK;GACnB,GAAI,KAAK,uBAAuB,SAC5B,EAAE,oBAAoB,KAAK,oBAAoB,GAC/C,EAAE;GACN,OAAO,KAAK;AACV,QAAI,KAAK,WAAW,OAAW,QAAO,KAAK,OAAO,IAAI;AACtD,WAAO,aAAa,KAAK,QAAQ,MAAM,IAAI;;GAE7C,MAAM,SAAS,KAAK;AAClB,QAAI,KAAK,WAAW,OAAW,QAAO,KAAK,SAAS,IAAI;AACxD,WAAO,KAAK,OAAO,KACjB;KACE,MAAM;KACN,OAAO;MACL,yBAAyB,KAAK;MAC9B,4BAA4B,KAAK;MAClC;KACF,EACD,YAAY,KAAK,SAAS,IAAI,CAC/B;;GAEH,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,YAAY,KAAK,KAAK,EAAE,GAAG,EAAE;GACzE;;CAEJ,CAAC;AAEF,gBAAgB,aACd,QACA,MACA,KACwD;CACxD,MAAM,OAAO,OAAO,UAAU;EAC5B,MAAM;EACN,OAAO;GACL,yBAAyB,KAAK;GAC9B,4BAA4B,KAAK;GAClC;EACF,CAAC;AACF,KAAI;AACF,aAAW,MAAM,SAAS,KAAK,OAAO,IAAI,CACxC,OAAM;AAER,OAAK,UAAU,KAAK;UACb,KAAK;AACZ,OAAK,gBAAgB,IAAI;AACzB,OAAK,UAAU,SAAU,IAAc,QAAQ;AAC/C,QAAM;WACE;AAKR,OAAK,KAAK"}

package/dist/model-tier/classify.d.ts

@@ -0,0 +1,34 @@
+import { ModelHint, ProviderLike } from "@graphorin/core";
+
+//#region src/model-tier/classify.d.ts
+
+/**
+ * Single entry in the classifier rule table.
+ *
+ * @stable
+ */
+interface ClassifierRule {
+  readonly tier: ModelHint;
+  readonly pattern: RegExp;
+  /** Human-readable family label (`'anthropic-claude-haiku'`, …). */
+  readonly family: string;
+}
+/**
+ * The static rule table. Order matters — higher-specificity entries
+ * come first (e.g. `claude-haiku` before `claude-`). Tests assert
+ * that the table covers the canonical 2026 model families.
+ *
+ * @stable
+ */
+declare const CLASSIFIER_RULES: readonly ClassifierRule[];
+/**
+ * Classify a `Provider`'s `modelId` into one of `'fast' | 'balanced' |
+ * 'smart'`. Returns `undefined` when the model id matches none of the
+ * canonical 2026 mappings (Ollama / OpenAI-compatible / unknown).
+ *
+ * @stable
+ */
+declare function classifyModelTier(provider: ProviderLike): ModelHint | undefined;
+//#endregion
+export { CLASSIFIER_RULES, ClassifierRule, classifyModelTier };
+//# sourceMappingURL=classify.d.ts.map

package/dist/model-tier/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","names":[],"sources":["../../src/model-tier/classify.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAwBiB,cAAA;iBACA;oBACG;;;;;;;;;;;cAYP,2BAA2B;;;;;;;;iBA4CxB,iBAAA,WAA4B,eAAe"}

package/dist/model-tier/classify.js

@@ -0,0 +1,117 @@
+import { InvalidProviderError } from "../errors/errors.js";
+
+//#region src/model-tier/classify.ts
+/**
+* The static rule table. Order matters — higher-specificity entries
+* come first (e.g. `claude-haiku` before `claude-`). Tests assert
+* that the table covers the canonical 2026 model families.
+*
+* @stable
+*/
+const CLASSIFIER_RULES = Object.freeze([
+	{
+		tier: "fast",
+		family: "anthropic-haiku",
+		pattern: /^claude(?:-[\d.]+)*-?haiku/
+	},
+	{
+		tier: "balanced",
+		family: "anthropic-sonnet",
+		pattern: /^claude(?:-[\d.]+)*-?sonnet/
+	},
+	{
+		tier: "smart",
+		family: "anthropic-opus",
+		pattern: /^claude(?:-[\d.]+)*-?opus/
+	},
+	{
+		tier: "smart",
+		family: "anthropic-fable",
+		pattern: /^claude.*fable/
+	},
+	{
+		tier: "smart",
+		family: "anthropic-mythos",
+		pattern: /^claude.*mythos/
+	},
+	{
+		tier: "fast",
+		family: "bedrock-claude-haiku",
+		pattern: /^anthropic\.claude(?:-[\d.]+)*-?haiku/
+	},
+	{
+		tier: "balanced",
+		family: "bedrock-claude-sonnet",
+		pattern: /^anthropic\.claude(?:-[\d.]+)*-?sonnet/
+	},
+	{
+		tier: "smart",
+		family: "bedrock-claude-opus",
+		pattern: /^anthropic\.claude(?:-[\d.]+)*-?opus/
+	},
+	{
+		tier: "fast",
+		family: "openai-mini",
+		pattern: /^gpt-(\d|\d+\.\d+)-?mini/
+	},
+	{
+		tier: "fast",
+		family: "openai-nano",
+		pattern: /^gpt-(\d|\d+\.\d+)-?nano/
+	},
+	{
+		tier: "balanced",
+		family: "openai-gpt",
+		pattern: /^gpt-(?!.*(?:mini|nano))/
+	},
+	{
+		tier: "smart",
+		family: "openai-reasoning",
+		pattern: /^o[1-9]\b/
+	},
+	{
+		tier: "smart",
+		family: "openai-reasoning-extended",
+		pattern: /^o[1-9][a-z-]/
+	},
+	{
+		tier: "fast",
+		family: "gemini-flash",
+		pattern: /^gemini.*flash/
+	},
+	{
+		tier: "balanced",
+		family: "gemini-pro",
+		pattern: /^gemini.*pro\b/
+	},
+	{
+		tier: "smart",
+		family: "gemini-ultra",
+		pattern: /^gemini.*ultra/
+	}
+]);
+/**
+* Classify a `Provider`'s `modelId` into one of `'fast' | 'balanced' |
+* 'smart'`. Returns `undefined` when the model id matches none of the
+* canonical 2026 mappings (Ollama / OpenAI-compatible / unknown).
+*
+* @stable
+*/
+function classifyModelTier(provider) {
+	if (provider === null || typeof provider !== "object") throw new InvalidProviderError("classifyModelTier: argument must be a Provider-shaped object.");
+	const modelId = provider.modelId;
+	if (typeof modelId !== "string" || modelId.length === 0) throw new InvalidProviderError("classifyModelTier: provider.modelId must be a non-empty string.");
+	const normalised = stripFamilyPrefix(modelId.toLowerCase());
+	for (const rule of CLASSIFIER_RULES) if (rule.pattern.test(normalised)) return rule.tier;
+}
+function stripFamilyPrefix(model) {
+	const slash = model.indexOf("/");
+	if (slash !== -1) return model.slice(slash + 1);
+	const colon = model.indexOf(":");
+	if (colon !== -1 && !model.startsWith("http")) return model.slice(colon + 1);
+	return model;
+}
+
+//#endregion
+export { CLASSIFIER_RULES, classifyModelTier };
+//# sourceMappingURL=classify.js.map

package/dist/model-tier/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","names":["CLASSIFIER_RULES: readonly ClassifierRule[]"],"sources":["../../src/model-tier/classify.ts"],"sourcesContent":["/**\n * Per-provider model-tier auto-classifier — returns\n * `'fast' | 'balanced' | 'smart' | undefined` for any model id. The\n * classifier is consumed by the agent runtime (Phase 12) to validate\n * operator-supplied tier mappings and to surface tier-not-mapped\n * recommendations.\n *\n * The dispatcher is a pure function; it reads from a small static\n * rule table keyed on regex patterns matched against the lowercased\n * model id. The table can be inspected via {@link CLASSIFIER_RULES}\n * for debugging and downstream tooling (CLI, dashboard, lint rules).\n *\n * @packageDocumentation\n */\n\nimport type { ModelHint, ProviderLike } from '@graphorin/core';\n\nimport { InvalidProviderError } from '../errors/errors.js';\n\n/**\n * Single entry in the classifier rule table.\n *\n * @stable\n */\nexport interface ClassifierRule {\n  readonly tier: ModelHint;\n  readonly pattern: RegExp;\n  /** Human-readable family label (`'anthropic-claude-haiku'`, …). */\n  readonly family: string;\n}\n\n/**\n * The static rule table. Order matters — higher-specificity entries\n * come first (e.g. `claude-haiku` before `claude-`). Tests assert\n * that the table covers the canonical 2026 model families.\n *\n * @stable\n */\nexport const CLASSIFIER_RULES: readonly ClassifierRule[] = Object.freeze([\n  // Anthropic — direct. PS-20: the version segment between `claude` and the\n  // family word can be multi-part (`claude-3-5-haiku`, `claude-3-7-sonnet`) or\n  // absent (`claude-haiku-4-5`), so allow zero-or-more `-<digits/dots>` groups.\n  { tier: 'fast', family: 'anthropic-haiku', pattern: /^claude(?:-[\\d.]+)*-?haiku/ },\n  { tier: 'balanced', family: 'anthropic-sonnet', pattern: /^claude(?:-[\\d.]+)*-?sonnet/ },\n  { tier: 'smart', family: 'anthropic-opus', pattern: /^claude(?:-[\\d.]+)*-?opus/ },\n  { tier: 'smart', family: 'anthropic-fable', pattern: /^claude.*fable/ },\n  { tier: 'smart', family: 'anthropic-mythos', pattern: /^claude.*mythos/ },\n  // Anthropic — via Bedrock.\n  {\n    tier: 'fast',\n    family: 'bedrock-claude-haiku',\n    pattern: /^anthropic\\.claude(?:-[\\d.]+)*-?haiku/,\n  },\n  {\n    tier: 'balanced',\n    family: 'bedrock-claude-sonnet',\n    pattern: /^anthropic\\.claude(?:-[\\d.]+)*-?sonnet/,\n  },\n  {\n    tier: 'smart',\n    family: 'bedrock-claude-opus',\n    pattern: /^anthropic\\.claude(?:-[\\d.]+)*-?opus/,\n  },\n  // OpenAI.\n  { tier: 'fast', family: 'openai-mini', pattern: /^gpt-(\\d|\\d+\\.\\d+)-?mini/ },\n  { tier: 'fast', family: 'openai-nano', pattern: /^gpt-(\\d|\\d+\\.\\d+)-?nano/ },\n  { tier: 'balanced', family: 'openai-gpt', pattern: /^gpt-(?!.*(?:mini|nano))/ },\n  { tier: 'smart', family: 'openai-reasoning', pattern: /^o[1-9]\\b/ },\n  { tier: 'smart', family: 'openai-reasoning-extended', pattern: /^o[1-9][a-z-]/ },\n  // Google Gemini.\n  { tier: 'fast', family: 'gemini-flash', pattern: /^gemini.*flash/ },\n  { tier: 'balanced', family: 'gemini-pro', pattern: /^gemini.*pro\\b/ },\n  { tier: 'smart', family: 'gemini-ultra', pattern: /^gemini.*ultra/ },\n]);\n\n/**\n * Classify a `Provider`'s `modelId` into one of `'fast' | 'balanced' |\n * 'smart'`. Returns `undefined` when the model id matches none of the\n * canonical 2026 mappings (Ollama / OpenAI-compatible / unknown).\n *\n * @stable\n */\nexport function classifyModelTier(provider: ProviderLike): ModelHint | undefined {\n  if (provider === null || typeof provider !== 'object') {\n    throw new InvalidProviderError('classifyModelTier: argument must be a Provider-shaped object.');\n  }\n  const modelId = provider.modelId;\n  if (typeof modelId !== 'string' || modelId.length === 0) {\n    throw new InvalidProviderError(\n      'classifyModelTier: provider.modelId must be a non-empty string.',\n    );\n  }\n  const normalised = stripFamilyPrefix(modelId.toLowerCase());\n  for (const rule of CLASSIFIER_RULES) {\n    if (rule.pattern.test(normalised)) return rule.tier;\n  }\n  return undefined;\n}\n\nfunction stripFamilyPrefix(model: string): string {\n  // Common prefixes used by adapters: `anthropic/...`, `openai/...`,\n  // `google/...`, `provider:model`, etc. Strip them so the rule\n  // patterns can stay anchored at `^`.\n  const slash = model.indexOf('/');\n  if (slash !== -1) return model.slice(slash + 1);\n  const colon = model.indexOf(':');\n  if (colon !== -1 && !model.startsWith('http')) {\n    // Skip URL-like values (`http://localhost:8080`) — `:` there is a\n    // port separator, not a provider/model split.\n    return model.slice(colon + 1);\n  }\n  return model;\n}\n"],"mappings":";;;;;;;;;;AAsCA,MAAaA,mBAA8C,OAAO,OAAO;CAIvE;EAAE,MAAM;EAAQ,QAAQ;EAAmB,SAAS;EAA8B;CAClF;EAAE,MAAM;EAAY,QAAQ;EAAoB,SAAS;EAA+B;CACxF;EAAE,MAAM;EAAS,QAAQ;EAAkB,SAAS;EAA6B;CACjF;EAAE,MAAM;EAAS,QAAQ;EAAmB,SAAS;EAAkB;CACvE;EAAE,MAAM;EAAS,QAAQ;EAAoB,SAAS;EAAmB;CAEzE;EACE,MAAM;EACN,QAAQ;EACR,SAAS;EACV;CACD;EACE,MAAM;EACN,QAAQ;EACR,SAAS;EACV;CACD;EACE,MAAM;EACN,QAAQ;EACR,SAAS;EACV;CAED;EAAE,MAAM;EAAQ,QAAQ;EAAe,SAAS;EAA4B;CAC5E;EAAE,MAAM;EAAQ,QAAQ;EAAe,SAAS;EAA4B;CAC5E;EAAE,MAAM;EAAY,QAAQ;EAAc,SAAS;EAA4B;CAC/E;EAAE,MAAM;EAAS,QAAQ;EAAoB,SAAS;EAAa;CACnE;EAAE,MAAM;EAAS,QAAQ;EAA6B,SAAS;EAAiB;CAEhF;EAAE,MAAM;EAAQ,QAAQ;EAAgB,SAAS;EAAkB;CACnE;EAAE,MAAM;EAAY,QAAQ;EAAc,SAAS;EAAkB;CACrE;EAAE,MAAM;EAAS,QAAQ;EAAgB,SAAS;EAAkB;CACrE,CAAC;;;;;;;;AASF,SAAgB,kBAAkB,UAA+C;AAC/E,KAAI,aAAa,QAAQ,OAAO,aAAa,SAC3C,OAAM,IAAI,qBAAqB,gEAAgE;CAEjG,MAAM,UAAU,SAAS;AACzB,KAAI,OAAO,YAAY,YAAY,QAAQ,WAAW,EACpD,OAAM,IAAI,qBACR,kEACD;CAEH,MAAM,aAAa,kBAAkB,QAAQ,aAAa,CAAC;AAC3D,MAAK,MAAM,QAAQ,iBACjB,KAAI,KAAK,QAAQ,KAAK,WAAW,CAAE,QAAO,KAAK;;AAKnD,SAAS,kBAAkB,OAAuB;CAIhD,MAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,KAAI,UAAU,GAAI,QAAO,MAAM,MAAM,QAAQ,EAAE;CAC/C,MAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,KAAI,UAAU,MAAM,CAAC,MAAM,WAAW,OAAO,CAG3C,QAAO,MAAM,MAAM,QAAQ,EAAE;AAE/B,QAAO"}

package/dist/model-tier/index.d.ts

@@ -0,0 +1,2 @@
+import { CLASSIFIER_RULES, ClassifierRule, classifyModelTier } from "./classify.js";
+export { CLASSIFIER_RULES, type ClassifierRule, classifyModelTier };

package/dist/model-tier/index.js

@@ -0,0 +1,3 @@
+import { CLASSIFIER_RULES, classifyModelTier } from "./classify.js";
+
+export { CLASSIFIER_RULES, classifyModelTier };

package/dist/provider.d.ts

@@ -0,0 +1,51 @@
+import { Provider, ProviderCapabilities, ReasoningRetention, Sensitivity } from "@graphorin/core";
+
+//#region src/provider.d.ts
+
+/**
+ * Options accepted by {@link createProvider}.
+ *
+ * @stable
+ */
+interface CreateProviderOptions {
+  /**
+   * Sensitivity tiers this provider is allowed to receive. When
+   * unset, the value is forwarded from the wrapped adapter (which is
+   * itself populated from the trust class for `baseUrl`-driven
+   * adapters).
+   */
+  readonly acceptsSensitivity?: ReadonlyArray<Sensitivity>;
+  /**
+   * Per-request override of the reasoning-retention default. The
+   * adapter's `capabilities.reasoningContract` decides the auto-
+   * detected default; this option pins a different value for every
+   * request the wrapper sees.
+   */
+  readonly reasoningRetention?: ReasoningRetention;
+  /**
+   * Optional capability override. Useful for narrowing what a
+   * downstream tool advertises (e.g. setting `multimodal: false`
+   * when the consumer's prompt cache is text-only).
+   */
+  readonly capabilities?: Partial<ProviderCapabilities>;
+}
+/**
+ * Wrap an adapter in the canonical `Provider` shape. Adapters returned
+ * by the bundled factories already implement `Provider`; passing them
+ * through `createProvider(...)` is the recommended entry point because
+ * it keeps the construction site documented and gives downstream
+ * middleware a single attachment surface.
+ *
+ * @example
+ * ```ts
+ * const provider = createProvider(vercelAdapter(model), {
+ *   acceptsSensitivity: ['public', 'internal'],
+ * });
+ * ```
+ *
+ * @stable
+ */
+declare function createProvider(adapter: Provider, options?: CreateProviderOptions): Provider;
+//#endregion
+export { CreateProviderOptions, createProvider };
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","names":[],"sources":["../src/provider.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAkCiB,qBAAA;;;;;;;gCAOe,cAAc;;;;;;;gCAOd;;;;;;0BAMN,QAAQ;;;;;;;;;;;;;;;;;;iBAmBlB,cAAA,UAAwB,oBAAmB,wBAA6B"}

package/dist/provider.js

@@ -0,0 +1,64 @@
+import { resolveReasoningRetention } from "./reasoning/retention.js";
+import { foldToolExamples } from "./tool-examples.js";
+
+//#region src/provider.ts
+/**
+* Wrap an adapter in the canonical `Provider` shape. Adapters returned
+* by the bundled factories already implement `Provider`; passing them
+* through `createProvider(...)` is the recommended entry point because
+* it keeps the construction site documented and gives downstream
+* middleware a single attachment surface.
+*
+* @example
+* ```ts
+* const provider = createProvider(vercelAdapter(model), {
+*   acceptsSensitivity: ['public', 'internal'],
+* });
+* ```
+*
+* @stable
+*/
+function createProvider(adapter, options = {}) {
+	const capabilities = {
+		...adapter.capabilities,
+		...options.capabilities
+	};
+	const acceptsSensitivity = options.acceptsSensitivity ?? adapter.acceptsSensitivity ?? void 0;
+	return {
+		name: adapter.name,
+		modelId: adapter.modelId,
+		capabilities,
+		...acceptsSensitivity ? { acceptsSensitivity } : {},
+		stream(req) {
+			return adapter.stream(applyDefaults(req, options, capabilities));
+		},
+		generate(req) {
+			return adapter.generate(applyDefaults(req, options, capabilities));
+		},
+		...adapter.countTokens ? { countTokens: adapter.countTokens.bind(adapter) } : {}
+	};
+}
+function applyDefaults(req, options, capabilities) {
+	let next = req;
+	if (next.tools !== void 0) {
+		const foldedTools = foldToolExamples(next.tools);
+		if (foldedTools !== next.tools) next = {
+			...next,
+			tools: foldedTools
+		};
+	}
+	const effectiveRetention = resolveReasoningRetention({
+		...next.reasoningRetention !== void 0 ? { requested: next.reasoningRetention } : {},
+		...options.reasoningRetention !== void 0 ? { overridden: options.reasoningRetention } : {},
+		...capabilities.reasoningContract !== void 0 ? { contract: capabilities.reasoningContract } : {}
+	});
+	if (effectiveRetention !== next.reasoningRetention) next = {
+		...next,
+		reasoningRetention: effectiveRetention
+	};
+	return next;
+}
+
+//#endregion
+export { createProvider };
+//# sourceMappingURL=provider.js.map

package/dist/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","names":["capabilities: ProviderCapabilities"],"sources":["../src/provider.ts"],"sourcesContent":["/**\n * `createProvider(...)` — wrap an adapter return value in the canonical\n * Graphorin `Provider` shape and apply optional sensitivity / capability\n * overrides.\n *\n * Adapters return a \"raw\" provider object; `createProvider(...)` gives\n * downstream code a single place to centralise:\n *\n * - per-instance `acceptsSensitivity` declarations,\n * - capability overrides (e.g. forcing `multimodal: false` for a tool\n *   that does not need it),\n * - default `reasoningRetention` resolution from the adapter's declared\n *   `reasoningContract`,\n * - and the agreed-upon `name` / `modelId` lock-in.\n *\n * @stable\n */\n\nimport type {\n  Provider,\n  ProviderCapabilities,\n  ProviderRequest,\n  ReasoningRetention,\n  Sensitivity,\n} from '@graphorin/core';\n\nimport { resolveReasoningRetention } from './reasoning/retention.js';\nimport { foldToolExamples } from './tool-examples.js';\n\n/**\n * Options accepted by {@link createProvider}.\n *\n * @stable\n */\nexport interface CreateProviderOptions {\n  /**\n   * Sensitivity tiers this provider is allowed to receive. When\n   * unset, the value is forwarded from the wrapped adapter (which is\n   * itself populated from the trust class for `baseUrl`-driven\n   * adapters).\n   */\n  readonly acceptsSensitivity?: ReadonlyArray<Sensitivity>;\n  /**\n   * Per-request override of the reasoning-retention default. The\n   * adapter's `capabilities.reasoningContract` decides the auto-\n   * detected default; this option pins a different value for every\n   * request the wrapper sees.\n   */\n  readonly reasoningRetention?: ReasoningRetention;\n  /**\n   * Optional capability override. Useful for narrowing what a\n   * downstream tool advertises (e.g. setting `multimodal: false`\n   * when the consumer's prompt cache is text-only).\n   */\n  readonly capabilities?: Partial<ProviderCapabilities>;\n}\n\n/**\n * Wrap an adapter in the canonical `Provider` shape. Adapters returned\n * by the bundled factories already implement `Provider`; passing them\n * through `createProvider(...)` is the recommended entry point because\n * it keeps the construction site documented and gives downstream\n * middleware a single attachment surface.\n *\n * @example\n * ```ts\n * const provider = createProvider(vercelAdapter(model), {\n *   acceptsSensitivity: ['public', 'internal'],\n * });\n * ```\n *\n * @stable\n */\nexport function createProvider(adapter: Provider, options: CreateProviderOptions = {}): Provider {\n  const capabilities: ProviderCapabilities = {\n    ...adapter.capabilities,\n    ...options.capabilities,\n  };\n  const acceptsSensitivity = options.acceptsSensitivity ?? adapter.acceptsSensitivity ?? undefined;\n\n  const wrapped: Provider = {\n    name: adapter.name,\n    modelId: adapter.modelId,\n    capabilities,\n    ...(acceptsSensitivity ? { acceptsSensitivity } : {}),\n    stream(req) {\n      return adapter.stream(applyDefaults(req, options, capabilities));\n    },\n    generate(req) {\n      return adapter.generate(applyDefaults(req, options, capabilities));\n    },\n    ...(adapter.countTokens ? { countTokens: adapter.countTokens.bind(adapter) } : {}),\n  };\n  return wrapped;\n}\n\nfunction applyDefaults(\n  req: ProviderRequest,\n  options: CreateProviderOptions,\n  capabilities: ProviderCapabilities,\n): ProviderRequest {\n  let next = req;\n  // A1: fold worked tool examples into the model-facing description so the model\n  // actually sees them (the wire contract carries them; adapters never rendered\n  // them). Deterministic ⇒ the tool spec stays prompt-cache-stable.\n  if (next.tools !== undefined) {\n    const foldedTools = foldToolExamples(next.tools);\n    if (foldedTools !== next.tools) next = { ...next, tools: foldedTools };\n  }\n  const effectiveRetention = resolveReasoningRetention({\n    ...(next.reasoningRetention !== undefined ? { requested: next.reasoningRetention } : {}),\n    ...(options.reasoningRetention !== undefined ? { overridden: options.reasoningRetention } : {}),\n    ...(capabilities.reasoningContract !== undefined\n      ? { contract: capabilities.reasoningContract }\n      : {}),\n  });\n  if (effectiveRetention !== next.reasoningRetention) {\n    next = { ...next, reasoningRetention: effectiveRetention };\n  }\n  return next;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,eAAe,SAAmB,UAAiC,EAAE,EAAY;CAC/F,MAAMA,eAAqC;EACzC,GAAG,QAAQ;EACX,GAAG,QAAQ;EACZ;CACD,MAAM,qBAAqB,QAAQ,sBAAsB,QAAQ,sBAAsB;AAevF,QAb0B;EACxB,MAAM,QAAQ;EACd,SAAS,QAAQ;EACjB;EACA,GAAI,qBAAqB,EAAE,oBAAoB,GAAG,EAAE;EACpD,OAAO,KAAK;AACV,UAAO,QAAQ,OAAO,cAAc,KAAK,SAAS,aAAa,CAAC;;EAElE,SAAS,KAAK;AACZ,UAAO,QAAQ,SAAS,cAAc,KAAK,SAAS,aAAa,CAAC;;EAEpE,GAAI,QAAQ,cAAc,EAAE,aAAa,QAAQ,YAAY,KAAK,QAAQ,EAAE,GAAG,EAAE;EAClF;;AAIH,SAAS,cACP,KACA,SACA,cACiB;CACjB,IAAI,OAAO;AAIX,KAAI,KAAK,UAAU,QAAW;EAC5B,MAAM,cAAc,iBAAiB,KAAK,MAAM;AAChD,MAAI,gBAAgB,KAAK,MAAO,QAAO;GAAE,GAAG;GAAM,OAAO;GAAa;;CAExE,MAAM,qBAAqB,0BAA0B;EACnD,GAAI,KAAK,uBAAuB,SAAY,EAAE,WAAW,KAAK,oBAAoB,GAAG,EAAE;EACvF,GAAI,QAAQ,uBAAuB,SAAY,EAAE,YAAY,QAAQ,oBAAoB,GAAG,EAAE;EAC9F,GAAI,aAAa,sBAAsB,SACnC,EAAE,UAAU,aAAa,mBAAmB,GAC5C,EAAE;EACP,CAAC;AACF,KAAI,uBAAuB,KAAK,mBAC9B,QAAO;EAAE,GAAG;EAAM,oBAAoB;EAAoB;AAE5D,QAAO"}

package/dist/reasoning/apply-policy.d.ts

@@ -0,0 +1,22 @@
+import { Message, ReasoningRetention } from "@graphorin/core";
+
+//#region src/reasoning/apply-policy.d.ts
+
+/**
+ * Inputs to {@link applyReasoningPolicy}.
+ *
+ * @stable
+ */
+interface ApplyReasoningPolicyInput {
+  readonly messages: ReadonlyArray<Message>;
+  readonly retention: ReasoningRetention;
+}
+/**
+ * Apply the resolved retention policy to the provided messages.
+ *
+ * @stable
+ */
+declare function applyReasoningPolicy(input: ApplyReasoningPolicyInput): ReadonlyArray<Message>;
+//#endregion
+export { ApplyReasoningPolicyInput, applyReasoningPolicy };
+//# sourceMappingURL=apply-policy.d.ts.map

package/dist/reasoning/apply-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-policy.d.ts","names":[],"sources":["../../src/reasoning/apply-policy.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAgCiB,yBAAA;qBACI,cAAc;sBACb;;;;;;;iBAQN,oBAAA,QAA4B,4BAA4B,cAAc"}

package/dist/reasoning/apply-policy.js

@@ -0,0 +1,47 @@
+//#region src/reasoning/apply-policy.ts
+/**
+* Apply the resolved retention policy to the provided messages.
+*
+* @stable
+*/
+function applyReasoningPolicy(input) {
+	if (input.retention === "pass-through-all") return input.messages;
+	return input.messages.map((msg) => {
+		if (msg.role !== "assistant") return msg;
+		return rewriteAssistantMessage(msg, input.retention);
+	});
+}
+function rewriteAssistantMessage(msg, retention) {
+	const content = msg.content;
+	if (typeof content === "string") return msg;
+	const filtered = [];
+	let mutated = false;
+	for (const part of content) {
+		if (part.type !== "reasoning") {
+			filtered.push(part);
+			continue;
+		}
+		if (retention === "strip") {
+			mutated = true;
+			continue;
+		}
+		if (retention === "pass-through-claude") if (isAnthropicShapedReasoning(part)) filtered.push(part);
+		else mutated = true;
+	}
+	if (!mutated) return msg;
+	return {
+		...msg,
+		content: filtered
+	};
+}
+function isAnthropicShapedReasoning(part) {
+	const meta = part.meta;
+	if (meta === void 0) return false;
+	if (meta.provider === "anthropic") return true;
+	if (typeof meta.signature === "string" && meta.signature.length > 0) return true;
+	return false;
+}
+
+//#endregion
+export { applyReasoningPolicy };
+//# sourceMappingURL=apply-policy.js.map

package/dist/reasoning/apply-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-policy.js","names":["filtered: MessageContent[]"],"sources":["../../src/reasoning/apply-policy.ts"],"sourcesContent":["/**\n * `applyReasoningPolicy` — given a list of `Message`s and the resolved\n * {@link ReasoningRetention}, return a transformed list with\n * `reasoning` content parts treated according to the policy:\n *\n * - `'strip'`              — drop every `reasoning` content part.\n * - `'pass-through-claude'` — keep parts that carry Anthropic-shaped\n *   metadata (`provider === 'anthropic'` OR a `signature` field);\n *   drop the rest.\n * - `'pass-through-all'`   — keep every `reasoning` content part\n *   unchanged.\n *\n * The transformation is shallow: only the `assistant` role's content\n * arrays are inspected (the only role that legitimately carries\n * reasoning blocks).\n *\n * @packageDocumentation\n */\n\nimport type {\n  AssistantMessage,\n  Message,\n  MessageContent,\n  ReasoningContent,\n  ReasoningRetention,\n} from '@graphorin/core';\n\n/**\n * Inputs to {@link applyReasoningPolicy}.\n *\n * @stable\n */\nexport interface ApplyReasoningPolicyInput {\n  readonly messages: ReadonlyArray<Message>;\n  readonly retention: ReasoningRetention;\n}\n\n/**\n * Apply the resolved retention policy to the provided messages.\n *\n * @stable\n */\nexport function applyReasoningPolicy(input: ApplyReasoningPolicyInput): ReadonlyArray<Message> {\n  if (input.retention === 'pass-through-all') return input.messages;\n  return input.messages.map((msg) => {\n    if (msg.role !== 'assistant') return msg;\n    return rewriteAssistantMessage(msg, input.retention);\n  });\n}\n\nfunction rewriteAssistantMessage(\n  msg: AssistantMessage,\n  retention: ReasoningRetention,\n): AssistantMessage {\n  const content = msg.content;\n  if (typeof content === 'string') return msg;\n  const filtered: MessageContent[] = [];\n  let mutated = false;\n  for (const part of content) {\n    if (part.type !== 'reasoning') {\n      filtered.push(part);\n      continue;\n    }\n    if (retention === 'strip') {\n      mutated = true;\n      continue;\n    }\n    if (retention === 'pass-through-claude') {\n      if (isAnthropicShapedReasoning(part)) {\n        filtered.push(part);\n      } else {\n        mutated = true;\n      }\n    }\n  }\n  if (!mutated) return msg;\n  return {\n    ...msg,\n    content: filtered,\n  };\n}\n\nfunction isAnthropicShapedReasoning(part: ReasoningContent): boolean {\n  const meta = part.meta;\n  if (meta === undefined) return false;\n  if (meta.provider === 'anthropic') return true;\n  if (typeof meta.signature === 'string' && meta.signature.length > 0) return true;\n  return false;\n}\n"],"mappings":";;;;;;AA0CA,SAAgB,qBAAqB,OAA0D;AAC7F,KAAI,MAAM,cAAc,mBAAoB,QAAO,MAAM;AACzD,QAAO,MAAM,SAAS,KAAK,QAAQ;AACjC,MAAI,IAAI,SAAS,YAAa,QAAO;AACrC,SAAO,wBAAwB,KAAK,MAAM,UAAU;GACpD;;AAGJ,SAAS,wBACP,KACA,WACkB;CAClB,MAAM,UAAU,IAAI;AACpB,KAAI,OAAO,YAAY,SAAU,QAAO;CACxC,MAAMA,WAA6B,EAAE;CACrC,IAAI,UAAU;AACd,MAAK,MAAM,QAAQ,SAAS;AAC1B,MAAI,KAAK,SAAS,aAAa;AAC7B,YAAS,KAAK,KAAK;AACnB;;AAEF,MAAI,cAAc,SAAS;AACzB,aAAU;AACV;;AAEF,MAAI,cAAc,sBAChB,KAAI,2BAA2B,KAAK,CAClC,UAAS,KAAK,KAAK;MAEnB,WAAU;;AAIhB,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO;EACL,GAAG;EACH,SAAS;EACV;;AAGH,SAAS,2BAA2B,MAAiC;CACnE,MAAM,OAAO,KAAK;AAClB,KAAI,SAAS,OAAW,QAAO;AAC/B,KAAI,KAAK,aAAa,YAAa,QAAO;AAC1C,KAAI,OAAO,KAAK,cAAc,YAAY,KAAK,UAAU,SAAS,EAAG,QAAO;AAC5E,QAAO"}

package/dist/reasoning/classify-contract.d.ts

@@ -0,0 +1,41 @@
+import { ReasoningContract } from "@graphorin/core";
+
+//#region src/reasoning/classify-contract.d.ts
+
+/**
+ * Single entry in the contract-classifier rule table.
+ *
+ * @stable
+ */
+interface ReasoningContractRule {
+  readonly contract: ReasoningContract;
+  readonly pattern: RegExp;
+  /** Human-readable family label. */
+  readonly family: string;
+}
+/**
+ * Static rule table. Higher-specificity entries come first. Mirrors
+ * the per-family matrix documented for the provider layer.
+ *
+ * @stable
+ */
+declare const REASONING_CONTRACT_RULES: readonly ReasoningContractRule[];
+/**
+ * Inputs to {@link inferReasoningContract}.
+ *
+ * @stable
+ */
+interface InferReasoningContractInput {
+  readonly modelId: string;
+  readonly provider?: string;
+}
+/**
+ * Return the canonical {@link ReasoningContract} for a model id, or
+ * `'optional'` for unknown / Ollama / OpenAI-compatible families.
+ *
+ * @stable
+ */
+declare function inferReasoningContract(input: InferReasoningContractInput): ReasoningContract;
+//#endregion
+export { InferReasoningContractInput, REASONING_CONTRACT_RULES, ReasoningContractRule, inferReasoningContract };
+//# sourceMappingURL=classify-contract.d.ts.map

package/dist/reasoning/classify-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-contract.d.ts","names":[],"sources":["../../src/reasoning/classify-contract.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAqBiB,qBAAA;qBACI;oBACD;;;;;;;;;;cAWP,mCAAmC;;;;;;UA6B/B,2BAAA;;;;;;;;;;iBAWD,sBAAA,QAA8B,8BAA8B"}

package/dist/reasoning/classify-contract.js

@@ -0,0 +1,59 @@
+//#region src/reasoning/classify-contract.ts
+/**
+* Static rule table. Higher-specificity entries come first. Mirrors
+* the per-family matrix documented for the provider layer.
+*
+* @stable
+*/
+const REASONING_CONTRACT_RULES = Object.freeze([
+	{
+		contract: "round-trip-required",
+		family: "anthropic-claude",
+		pattern: /^claude(?:-\d|-)/
+	},
+	{
+		contract: "round-trip-required",
+		family: "bedrock-claude",
+		pattern: /^anthropic\.claude/
+	},
+	{
+		contract: "hidden",
+		family: "openai-reasoning",
+		pattern: /^o[1-9]\b/
+	},
+	{
+		contract: "hidden",
+		family: "openai-reasoning-extended",
+		pattern: /^o[1-9][a-z-]/
+	},
+	{
+		contract: "hidden",
+		family: "gemini-reasoning",
+		pattern: /^gemini.*(?:thinking|reasoning)/
+	}
+]);
+/**
+* Return the canonical {@link ReasoningContract} for a model id, or
+* `'optional'` for unknown / Ollama / OpenAI-compatible families.
+*
+* @stable
+*/
+function inferReasoningContract(input) {
+	if (typeof input.modelId !== "string" || input.modelId.length === 0) return "optional";
+	const provider = input.provider?.toLowerCase();
+	if (provider === "anthropic" || provider === "bedrock") return "round-trip-required";
+	const normalised = stripPrefix(input.modelId.toLowerCase());
+	for (const rule of REASONING_CONTRACT_RULES) if (rule.pattern.test(normalised)) return rule.contract;
+	return "optional";
+}
+function stripPrefix(model) {
+	const slash = model.indexOf("/");
+	if (slash !== -1) return model.slice(slash + 1);
+	const colon = model.indexOf(":");
+	if (colon !== -1 && !model.startsWith("http")) return model.slice(colon + 1);
+	return model;
+}
+
+//#endregion
+export { REASONING_CONTRACT_RULES, inferReasoningContract };
+//# sourceMappingURL=classify-contract.js.map

package/dist/reasoning/classify-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-contract.js","names":["REASONING_CONTRACT_RULES: readonly ReasoningContractRule[]"],"sources":["../../src/reasoning/classify-contract.ts"],"sourcesContent":["/**\n * `inferReasoningContract` — derive the canonical\n * {@link ReasoningContract} value for a model id. Adapters that wrap\n * cloud-LLM language-model values call this at construction time so\n * the runtime can pick the correct\n * {@link import('@graphorin/core').ReasoningRetention} default.\n *\n * The classifier is a pure function with the same shape as the\n * `classifyModelTier` family: a small static rule table matched\n * against the lowercased + prefix-stripped model id.\n *\n * @packageDocumentation\n */\n\nimport type { ReasoningContract } from '@graphorin/core';\n\n/**\n * Single entry in the contract-classifier rule table.\n *\n * @stable\n */\nexport interface ReasoningContractRule {\n  readonly contract: ReasoningContract;\n  readonly pattern: RegExp;\n  /** Human-readable family label. */\n  readonly family: string;\n}\n\n/**\n * Static rule table. Higher-specificity entries come first. Mirrors\n * the per-family matrix documented for the provider layer.\n *\n * @stable\n */\nexport const REASONING_CONTRACT_RULES: readonly ReasoningContractRule[] = Object.freeze([\n  // Anthropic Claude families (and Bedrock-distributed equivalents).\n  {\n    contract: 'round-trip-required',\n    family: 'anthropic-claude',\n    pattern: /^claude(?:-\\d|-)/,\n  },\n  {\n    contract: 'round-trip-required',\n    family: 'bedrock-claude',\n    pattern: /^anthropic\\.claude/,\n  },\n  // OpenAI hidden chain-of-thought reasoning models.\n  { contract: 'hidden', family: 'openai-reasoning', pattern: /^o[1-9]\\b/ },\n  { contract: 'hidden', family: 'openai-reasoning-extended', pattern: /^o[1-9][a-z-]/ },\n  // Google Gemini reasoning families (the dedicated thinking variants;\n  // the regular pro / flash families do not require round-tripping).\n  {\n    contract: 'hidden',\n    family: 'gemini-reasoning',\n    pattern: /^gemini.*(?:thinking|reasoning)/,\n  },\n]);\n\n/**\n * Inputs to {@link inferReasoningContract}.\n *\n * @stable\n */\nexport interface InferReasoningContractInput {\n  readonly modelId: string;\n  readonly provider?: string;\n}\n\n/**\n * Return the canonical {@link ReasoningContract} for a model id, or\n * `'optional'` for unknown / Ollama / OpenAI-compatible families.\n *\n * @stable\n */\nexport function inferReasoningContract(input: InferReasoningContractInput): ReasoningContract {\n  if (typeof input.modelId !== 'string' || input.modelId.length === 0) {\n    return 'optional';\n  }\n  const provider = input.provider?.toLowerCase();\n  // Provider-explicit short-circuits — let cloud-LLM consumers tag\n  // their model with `provider: 'anthropic'` even when the modelId is\n  // a non-canonical alias (e.g. `legacy-thinking-router`).\n  if (provider === 'anthropic' || provider === 'bedrock') {\n    return 'round-trip-required';\n  }\n  const normalised = stripPrefix(input.modelId.toLowerCase());\n  for (const rule of REASONING_CONTRACT_RULES) {\n    if (rule.pattern.test(normalised)) return rule.contract;\n  }\n  return 'optional';\n}\n\nfunction stripPrefix(model: string): string {\n  const slash = model.indexOf('/');\n  if (slash !== -1) return model.slice(slash + 1);\n  const colon = model.indexOf(':');\n  if (colon !== -1 && !model.startsWith('http')) {\n    return model.slice(colon + 1);\n  }\n  return model;\n}\n"],"mappings":";;;;;;;AAkCA,MAAaA,2BAA6D,OAAO,OAAO;CAEtF;EACE,UAAU;EACV,QAAQ;EACR,SAAS;EACV;CACD;EACE,UAAU;EACV,QAAQ;EACR,SAAS;EACV;CAED;EAAE,UAAU;EAAU,QAAQ;EAAoB,SAAS;EAAa;CACxE;EAAE,UAAU;EAAU,QAAQ;EAA6B,SAAS;EAAiB;CAGrF;EACE,UAAU;EACV,QAAQ;EACR,SAAS;EACV;CACF,CAAC;;;;;;;AAkBF,SAAgB,uBAAuB,OAAuD;AAC5F,KAAI,OAAO,MAAM,YAAY,YAAY,MAAM,QAAQ,WAAW,EAChE,QAAO;CAET,MAAM,WAAW,MAAM,UAAU,aAAa;AAI9C,KAAI,aAAa,eAAe,aAAa,UAC3C,QAAO;CAET,MAAM,aAAa,YAAY,MAAM,QAAQ,aAAa,CAAC;AAC3D,MAAK,MAAM,QAAQ,yBACjB,KAAI,KAAK,QAAQ,KAAK,WAAW,CAAE,QAAO,KAAK;AAEjD,QAAO;;AAGT,SAAS,YAAY,OAAuB;CAC1C,MAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,KAAI,UAAU,GAAI,QAAO,MAAM,MAAM,QAAQ,EAAE;CAC/C,MAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,KAAI,UAAU,MAAM,CAAC,MAAM,WAAW,OAAO,CAC3C,QAAO,MAAM,MAAM,QAAQ,EAAE;AAE/B,QAAO"}

package/dist/reasoning/index.d.ts

@@ -0,0 +1,4 @@
+import { ApplyReasoningPolicyInput, applyReasoningPolicy } from "./apply-policy.js";
+import { InferReasoningContractInput, REASONING_CONTRACT_RULES, ReasoningContractRule, inferReasoningContract } from "./classify-contract.js";
+import { REASONING_RETENTION_DEFAULTS, ResolveReasoningRetentionInput, resolveReasoningRetention } from "./retention.js";
+export { type ApplyReasoningPolicyInput, type InferReasoningContractInput, REASONING_CONTRACT_RULES, REASONING_RETENTION_DEFAULTS, type ReasoningContractRule, type ResolveReasoningRetentionInput, applyReasoningPolicy, inferReasoningContract, resolveReasoningRetention };

package/dist/reasoning/index.js

@@ -0,0 +1,5 @@
+import { applyReasoningPolicy } from "./apply-policy.js";
+import { REASONING_RETENTION_DEFAULTS, resolveReasoningRetention } from "./retention.js";
+import { REASONING_CONTRACT_RULES, inferReasoningContract } from "./classify-contract.js";
+
+export { REASONING_CONTRACT_RULES, REASONING_RETENTION_DEFAULTS, applyReasoningPolicy, inferReasoningContract, resolveReasoningRetention };

package/dist/reasoning/retention.d.ts

@@ -0,0 +1,39 @@
+import { ReasoningContract, ReasoningRetention } from "@graphorin/core";
+
+//#region src/reasoning/retention.d.ts
+
+/**
+ * Map from `ReasoningContract` to the conservative default
+ * `ReasoningRetention` value used when no override is supplied.
+ *
+ * @stable
+ */
+declare const REASONING_RETENTION_DEFAULTS: Readonly<Record<ReasoningContract, ReasoningRetention>>;
+/**
+ * Inputs to {@link resolveReasoningRetention}.
+ *
+ * @stable
+ */
+interface ResolveReasoningRetentionInput {
+  /** Explicit per-request override (highest precedence). */
+  readonly requested?: ReasoningRetention;
+  /** Instance-level override supplied to `createProvider({...})`. */
+  readonly overridden?: ReasoningRetention;
+  /** Adapter-declared capability (lowest precedence). */
+  readonly contract?: ReasoningContract;
+}
+/**
+ * Resolve the effective {@link ReasoningRetention} value for a single
+ * request. The resolution is precedence-driven:
+ *
+ * 1. `requested` wins if defined.
+ * 2. `overridden` wins next.
+ * 3. The default for `contract` is used if the contract is known.
+ * 4. `'strip'` is the conservative fallback when no input is supplied.
+ *
+ * @stable
+ */
+declare function resolveReasoningRetention(input: ResolveReasoningRetentionInput): ReasoningRetention;
+//#endregion
+export { REASONING_RETENTION_DEFAULTS, ResolveReasoningRetentionInput, resolveReasoningRetention };
+//# sourceMappingURL=retention.d.ts.map

package/dist/reasoning/retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention.d.ts","names":[],"sources":["../../src/reasoning/retention.ts"],"sourcesContent":[],"mappings":";;;;AAsDA;;;;;;cAhCa,8BAA8B,SAAS,OAAO,mBAAmB;;;;;;UAY7D,8BAAA;;uBAEM;;wBAEC;;sBAEF;;;;;;;;;;;;;iBAcN,yBAAA,QACP,iCACN"}