@graphorin/provider 0.5.0

package/dist/counters/serialize.d.ts

@@ -0,0 +1,37 @@
+import { Message } from "@graphorin/core";
+
+//#region src/counters/serialize.d.ts
+
+/**
+ * Plain-text projection of a {@link Message}. The shape is what the
+ * counter actually feeds the tokenizer.
+ *
+ * @internal
+ */
+interface SerializedMessage {
+  readonly role: string;
+  readonly text: string;
+  readonly toolCalls: ReadonlyArray<{
+    readonly name: string;
+    readonly args: string;
+  }>;
+}
+/**
+ * Project a `Message` into a flat string suitable for tokenizers that
+ * do not understand multimodal content. Image / audio / file parts
+ * are replaced with the canonical placeholder `[image]` / `[audio]` /
+ * `[file]` so byte counts stay deterministic.
+ *
+ * @internal
+ */
+declare function serialiseMessageForCount(msg: Message): SerializedMessage;
+/**
+ * Render a `SerializedMessage` as a single string with role prefix.
+ * Useful for naive estimators that count by character length.
+ *
+ * @internal
+ */
+declare function serializedToString(msg: SerializedMessage): string;
+//#endregion
+export { SerializedMessage, serialiseMessageForCount, serializedToString };
+//# sourceMappingURL=serialize.d.ts.map

package/dist/counters/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","names":[],"sources":["../../src/counters/serialize.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAgBiB,iBAAA;;;sBAGK;;;;;;;;;;;;;iBAWN,wBAAA,MAA8B,UAAU;;;;;;;iBAgDxC,kBAAA,MAAwB"}

package/dist/counters/serialize.js

@@ -0,0 +1,57 @@
+//#region src/counters/serialize.ts
+/**
+* Project a `Message` into a flat string suitable for tokenizers that
+* do not understand multimodal content. Image / audio / file parts
+* are replaced with the canonical placeholder `[image]` / `[audio]` /
+* `[file]` so byte counts stay deterministic.
+*
+* @internal
+*/
+function serialiseMessageForCount(msg) {
+	return {
+		role: msg.role,
+		text: serialiseContent(msg.content),
+		toolCalls: msg.toolCalls?.map((tc) => ({
+			name: tc.toolName,
+			args: typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args)
+		})) ?? []
+	};
+}
+function serialiseContent(content) {
+	if (typeof content === "string") return content;
+	const buffer = [];
+	for (const part of content) switch (part.type) {
+		case "text":
+			buffer.push(part.text);
+			break;
+		case "image":
+			buffer.push("[image]");
+			break;
+		case "audio":
+			buffer.push("[audio]");
+			break;
+		case "file":
+			buffer.push(`[file:${part.mimeType}]`);
+			break;
+		case "reasoning":
+			buffer.push(part.text);
+			break;
+		default: break;
+	}
+	return buffer.join("\n");
+}
+/**
+* Render a `SerializedMessage` as a single string with role prefix.
+* Useful for naive estimators that count by character length.
+*
+* @internal
+*/
+function serializedToString(msg) {
+	const parts = [`[${msg.role}]`, msg.text];
+	for (const tc of msg.toolCalls) parts.push(`[tool-call:${tc.name}] ${tc.args}`);
+	return parts.join("\n");
+}
+
+//#endregion
+export { serialiseMessageForCount, serializedToString };
+//# sourceMappingURL=serialize.js.map

package/dist/counters/serialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.js","names":["buffer: string[]"],"sources":["../../src/counters/serialize.ts"],"sourcesContent":["/**\n * Canonical text-only serialization of a Graphorin `Message`. Used by\n * counters that lack a vendor-native API (`JsTiktokenCounter`,\n * `HeuristicCounter`).\n *\n * @internal\n */\n\nimport type { Message, MessageContent } from '@graphorin/core';\n\n/**\n * Plain-text projection of a {@link Message}. The shape is what the\n * counter actually feeds the tokenizer.\n *\n * @internal\n */\nexport interface SerializedMessage {\n  readonly role: string;\n  readonly text: string;\n  readonly toolCalls: ReadonlyArray<{ readonly name: string; readonly args: string }>;\n}\n\n/**\n * Project a `Message` into a flat string suitable for tokenizers that\n * do not understand multimodal content. Image / audio / file parts\n * are replaced with the canonical placeholder `[image]` / `[audio]` /\n * `[file]` so byte counts stay deterministic.\n *\n * @internal\n */\nexport function serialiseMessageForCount(msg: Message): SerializedMessage {\n  const role = msg.role;\n  const text = serialiseContent(msg.content);\n  const toolCalls =\n    (msg as { toolCalls?: ReadonlyArray<{ toolName: string; args: unknown }> }).toolCalls?.map(\n      (tc) => ({\n        name: tc.toolName,\n        args: typeof tc.args === 'string' ? tc.args : JSON.stringify(tc.args),\n      }),\n    ) ?? [];\n  return { role, text, toolCalls };\n}\n\nfunction serialiseContent(content: string | ReadonlyArray<MessageContent>): string {\n  if (typeof content === 'string') return content;\n  const buffer: string[] = [];\n  for (const part of content) {\n    switch (part.type) {\n      case 'text':\n        buffer.push(part.text);\n        break;\n      case 'image':\n        buffer.push('[image]');\n        break;\n      case 'audio':\n        buffer.push('[audio]');\n        break;\n      case 'file':\n        buffer.push(`[file:${part.mimeType}]`);\n        break;\n      case 'reasoning':\n        buffer.push(part.text);\n        break;\n      default:\n        // Unknown content variants are silently skipped to keep the\n        // counter forward-compatible.\n        break;\n    }\n  }\n  return buffer.join('\\n');\n}\n\n/**\n * Render a `SerializedMessage` as a single string with role prefix.\n * Useful for naive estimators that count by character length.\n *\n * @internal\n */\nexport function serializedToString(msg: SerializedMessage): string {\n  const parts = [`[${msg.role}]`, msg.text];\n  for (const tc of msg.toolCalls) {\n    parts.push(`[tool-call:${tc.name}] ${tc.args}`);\n  }\n  return parts.join('\\n');\n}\n"],"mappings":";;;;;;;;;AA8BA,SAAgB,yBAAyB,KAAiC;AAUxE,QAAO;EAAE,MATI,IAAI;EASF,MARF,iBAAiB,IAAI,QAAQ;EAQrB,WANlB,IAA2E,WAAW,KACpF,QAAQ;GACP,MAAM,GAAG;GACT,MAAM,OAAO,GAAG,SAAS,WAAW,GAAG,OAAO,KAAK,UAAU,GAAG,KAAK;GACtE,EACF,IAAI,EAAE;EACuB;;AAGlC,SAAS,iBAAiB,SAAyD;AACjF,KAAI,OAAO,YAAY,SAAU,QAAO;CACxC,MAAMA,SAAmB,EAAE;AAC3B,MAAK,MAAM,QAAQ,QACjB,SAAQ,KAAK,MAAb;EACE,KAAK;AACH,UAAO,KAAK,KAAK,KAAK;AACtB;EACF,KAAK;AACH,UAAO,KAAK,UAAU;AACtB;EACF,KAAK;AACH,UAAO,KAAK,UAAU;AACtB;EACF,KAAK;AACH,UAAO,KAAK,SAAS,KAAK,SAAS,GAAG;AACtC;EACF,KAAK;AACH,UAAO,KAAK,KAAK,KAAK;AACtB;EACF,QAGE;;AAGN,QAAO,OAAO,KAAK,KAAK;;;;;;;;AAS1B,SAAgB,mBAAmB,KAAgC;CACjE,MAAM,QAAQ,CAAC,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK;AACzC,MAAK,MAAM,MAAM,IAAI,UACnB,OAAM,KAAK,cAAc,GAAG,KAAK,IAAI,GAAG,OAAO;AAEjD,QAAO,MAAM,KAAK,KAAK"}

package/dist/errors/errors.d.ts

@@ -0,0 +1,167 @@
+//#region src/errors/errors.d.ts
+/**
+ * Typed error hierarchy for `@graphorin/provider`. Every error class
+ * carries a stable `kind` discriminant (lowercase, kebab-case) plus an
+ * optional `hint` string pointing the user at the recommended fix.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base class for every error thrown by `@graphorin/provider`. Consumers
+ * narrow on the discriminant `kind` rather than `instanceof` — both
+ * work, but discriminants are subclass-friendly.
+ *
+ * @stable
+ */
+declare class GraphorinProviderError extends Error {
+  readonly name: string;
+  /** Stable discriminant — `'middleware-ordering'`, `'rate-limit-exceeded'`, … */
+  readonly kind: string;
+  /** Optional remediation hint shown alongside the message. */
+  readonly hint?: string;
+  constructor(kind: string, message: string, options?: {
+    cause?: unknown;
+    hint?: string;
+  });
+}
+/**
+ * The middleware composer detected an out-of-order middleware. The
+ * `offendingPair` field carries the `[outer, inner]` middleware names
+ * that violated the canonical order so consumers can surface a precise
+ * fix in IDE diagnostics.
+ *
+ * @stable
+ */
+declare class MiddlewareOrderingError extends GraphorinProviderError {
+  readonly name = "MiddlewareOrderingError";
+  readonly offendingPair: readonly [string, string];
+  readonly canonicalOrder: readonly string[];
+  constructor(args: {
+    offendingPair: readonly [string, string];
+    canonicalOrder: readonly string[];
+    message?: string;
+  });
+}
+/**
+ * `withRedaction` was missing at production startup. Thrown by the
+ * production hook applied to every composed provider when
+ * `process.env.NODE_ENV === 'production'`.
+ *
+ * @stable
+ */
+declare class MissingProductionMiddlewareError extends GraphorinProviderError {
+  readonly name = "MissingProductionMiddlewareError";
+  readonly missing: string;
+  constructor(missing: string);
+}
+/**
+ * `withCostLimit` exceeded its configured ceiling. Carries the
+ * triggering scope (`session`, `agent`, `run`, …) so the caller can
+ * decide how to surface the breach.
+ *
+ * @stable
+ */
+declare class CostBudgetExceededError extends GraphorinProviderError {
+  readonly name = "CostBudgetExceededError";
+  readonly scope: string;
+  readonly limit: number;
+  readonly observed: number;
+  constructor(args: {
+    scope: string;
+    limit: number;
+    observed: number;
+    currency?: string;
+  });
+}
+/**
+ * `withRateLimit` exhausted its bucket and the caller did not opt
+ * into `'queue'` mode.
+ *
+ * @stable
+ */
+declare class RateLimitExceededError extends GraphorinProviderError {
+  readonly name = "RateLimitExceededError";
+  readonly retryAfterMs: number;
+  constructor(retryAfterMs: number);
+}
+/**
+ * `withRedaction` detected a hit AND the policy is configured for
+ * `failClosed: true`. The matched value is **never** part of the
+ * message — only the pattern name and field path.
+ *
+ * @stable
+ */
+declare class PromptRedactionError extends GraphorinProviderError {
+  readonly name = "PromptRedactionError";
+  readonly patternName: string;
+  readonly fieldPath: string;
+  readonly role?: string;
+  constructor(args: {
+    patternName: string;
+    fieldPath: string;
+    role?: string;
+  });
+}
+/**
+ * Raised when a `baseUrl`-driven local adapter is configured against
+ * a public host over plaintext HTTP. Adapters refuse to start unless
+ * `allowInsecureTransport: true` is supplied (and the override is
+ * audit-logged).
+ *
+ * @stable
+ */
+declare class LocalProviderInsecureTransportError extends GraphorinProviderError {
+  readonly name = "LocalProviderInsecureTransportError";
+  readonly baseUrl: string;
+  constructor(baseUrl: string);
+}
+/**
+ * Legacy alias preserved for one minor; prefer
+ * {@link LocalProviderInsecureTransportError}. Removed in v0.2.
+ *
+ * @deprecated Use {@link LocalProviderInsecureTransportError} instead.
+ */
+declare const OllamaInsecureTransportError: typeof LocalProviderInsecureTransportError;
+type OllamaInsecureTransportError = LocalProviderInsecureTransportError;
+/**
+ * Wrapped HTTP error returned by an adapter. Carries the original
+ * status code so middleware (`withRetry`, `withFallback`) can decide
+ * whether the error is retryable.
+ *
+ * @stable
+ */
+declare class ProviderHttpError extends GraphorinProviderError {
+  readonly name = "ProviderHttpError";
+  readonly status: number;
+  readonly providerName: string;
+  constructor(args: {
+    providerName: string;
+    status: number;
+    message: string;
+    cause?: unknown;
+  });
+}
+/**
+ * The streaming response did not match the documented wire format
+ * (e.g. malformed SSE chunk, truncated JSON).
+ *
+ * @stable
+ */
+declare class ProviderStreamParseError extends GraphorinProviderError {
+  readonly name = "ProviderStreamParseError";
+  readonly providerName: string;
+  constructor(providerName: string, message: string, cause?: unknown);
+}
+/**
+ * The classifier dispatcher was given a non-Provider value. Programming
+ * error; fail-fast at the boundary.
+ *
+ * @stable
+ */
+declare class InvalidProviderError extends GraphorinProviderError {
+  readonly name = "InvalidProviderError";
+  constructor(message: string);
+}
+//#endregion
+export { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/errors/errors.ts"],"sourcesContent":[],"mappings":";;AAeA;AAwBA;AAiCA;AAyBA;AA2BA;AAmBA;AA6BA;AAyBA;AACA;AASA;AAoBA;AAkBA;;cAtOa,sBAAA,SAA+B,KAAA;;;;;;;;;;;;;;;;;;;cAwB/B,uBAAA,SAAgC,sBAAA;;;;;;;;;;;;;;;;;cAiChC,gCAAA,SAAyC,sBAAA;;;;;;;;;;;;cAyBzC,uBAAA,SAAgC,sBAAA;;;;;;;;;;;;;;;;;;cA2BhC,sBAAA,SAA+B,sBAAA;;;;;;;;;;;;cAmB/B,oBAAA,SAA6B,sBAAA;;;;;;;;;;;;;;;;;;;cA6B7B,mCAAA,SAA4C,sBAAA;;;;;;;;;;;cAyB5C,qCAA4B;KAC7B,4BAAA,GAA+B;;;;;;;;cAS9B,iBAAA,SAA0B,sBAAA;;;;;;;;;;;;;;;;;cAoB1B,wBAAA,SAAiC,sBAAA;;;;;;;;;;;cAkBjC,oBAAA,SAA6B,sBAAA"}

package/dist/errors/errors.js

@@ -0,0 +1,182 @@
+//#region src/errors/errors.ts
+/**
+* Typed error hierarchy for `@graphorin/provider`. Every error class
+* carries a stable `kind` discriminant (lowercase, kebab-case) plus an
+* optional `hint` string pointing the user at the recommended fix.
+*
+* @packageDocumentation
+*/
+/**
+* Base class for every error thrown by `@graphorin/provider`. Consumers
+* narrow on the discriminant `kind` rather than `instanceof` — both
+* work, but discriminants are subclass-friendly.
+*
+* @stable
+*/
+var GraphorinProviderError = class extends Error {
+	name = "GraphorinProviderError";
+	/** Stable discriminant — `'middleware-ordering'`, `'rate-limit-exceeded'`, … */
+	kind;
+	/** Optional remediation hint shown alongside the message. */
+	hint;
+	constructor(kind, message, options) {
+		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.kind = kind;
+		if (options?.hint !== void 0) this.hint = options.hint;
+	}
+};
+/**
+* The middleware composer detected an out-of-order middleware. The
+* `offendingPair` field carries the `[outer, inner]` middleware names
+* that violated the canonical order so consumers can surface a precise
+* fix in IDE diagnostics.
+*
+* @stable
+*/
+var MiddlewareOrderingError = class extends GraphorinProviderError {
+	name = "MiddlewareOrderingError";
+	offendingPair;
+	canonicalOrder;
+	constructor(args) {
+		super("middleware-ordering", args.message ?? `Middleware order violation: '${args.offendingPair[0]}' must not wrap '${args.offendingPair[1]}'. Canonical order (outer → inner): ${args.canonicalOrder.join(" → ")}.`, { hint: "Reorder the middleware array passed to composeProviderMiddleware([...]) to match the canonical order; see @graphorin/provider/middleware for documentation." });
+		this.offendingPair = args.offendingPair;
+		this.canonicalOrder = args.canonicalOrder;
+	}
+};
+/**
+* `withRedaction` was missing at production startup. Thrown by the
+* production hook applied to every composed provider when
+* `process.env.NODE_ENV === 'production'`.
+*
+* @stable
+*/
+var MissingProductionMiddlewareError = class extends GraphorinProviderError {
+	name = "MissingProductionMiddlewareError";
+	missing;
+	constructor(missing) {
+		super("missing-production-middleware", `Production startup hook: required middleware '${missing}' is missing from the provider chain.`, { hint: `Compose '${missing}' as the innermost layer (closest to the underlying provider) before deploying. See @graphorin/provider/middleware for the canonical composition order.` });
+		this.missing = missing;
+	}
+};
+/**
+* `withCostLimit` exceeded its configured ceiling. Carries the
+* triggering scope (`session`, `agent`, `run`, …) so the caller can
+* decide how to surface the breach.
+*
+* @stable
+*/
+var CostBudgetExceededError = class extends GraphorinProviderError {
+	name = "CostBudgetExceededError";
+	scope;
+	limit;
+	observed;
+	constructor(args) {
+		super("cost-budget-exceeded", `Cost budget exceeded for '${args.scope}': observed ${args.observed.toFixed(4)} ${args.currency ?? "USD"} > limit ${args.limit.toFixed(4)} ${args.currency ?? "USD"}.`, { hint: "Raise the limit in withCostLimit({...}), tighten the prompt, or switch to a cheaper model tier." });
+		this.scope = args.scope;
+		this.limit = args.limit;
+		this.observed = args.observed;
+	}
+};
+/**
+* `withRateLimit` exhausted its bucket and the caller did not opt
+* into `'queue'` mode.
+*
+* @stable
+*/
+var RateLimitExceededError = class extends GraphorinProviderError {
+	name = "RateLimitExceededError";
+	retryAfterMs;
+	constructor(retryAfterMs) {
+		super("rate-limit-exceeded", `Rate limit exceeded; retry after ${retryAfterMs}ms.`, { hint: "Slow down the request rate, raise the bucket size in withRateLimit({...}), or switch to mode: \"queue\"." });
+		this.retryAfterMs = retryAfterMs;
+	}
+};
+/**
+* `withRedaction` detected a hit AND the policy is configured for
+* `failClosed: true`. The matched value is **never** part of the
+* message — only the pattern name and field path.
+*
+* @stable
+*/
+var PromptRedactionError = class extends GraphorinProviderError {
+	name = "PromptRedactionError";
+	patternName;
+	fieldPath;
+	role;
+	constructor(args) {
+		super("prompt-redaction-fail-closed", `Outbound prompt-redaction policy is fail-closed and matched pattern '${args.patternName}' at '${args.fieldPath}'${args.role ? ` (role: ${args.role})` : ""}.`, { hint: "Sanitize the prompt before calling the provider, or disable failClosed in withRedaction({...}) for this environment." });
+		this.patternName = args.patternName;
+		this.fieldPath = args.fieldPath;
+		if (args.role !== void 0) this.role = args.role;
+	}
+};
+/**
+* Raised when a `baseUrl`-driven local adapter is configured against
+* a public host over plaintext HTTP. Adapters refuse to start unless
+* `allowInsecureTransport: true` is supplied (and the override is
+* audit-logged).
+*
+* @stable
+*/
+var LocalProviderInsecureTransportError = class extends GraphorinProviderError {
+	name = "LocalProviderInsecureTransportError";
+	baseUrl;
+	constructor(baseUrl) {
+		super("local-provider-insecure-transport", `Refusing to start: the provider baseUrl '${baseUrl}' is public AND plaintext (http://). Switch to https:// or set allowInsecureTransport: true to acknowledge the risk.`, { hint: "Public local-LLM endpoints must be served over TLS. Acceptable alternatives: terminate TLS in front of the model server, tunnel through SSH / WireGuard / Tailscale, or pass allowInsecureTransport: true (audit-logged)." });
+		this.baseUrl = baseUrl;
+	}
+};
+/**
+* Legacy alias preserved for one minor; prefer
+* {@link LocalProviderInsecureTransportError}. Removed in v0.2.
+*
+* @deprecated Use {@link LocalProviderInsecureTransportError} instead.
+*/
+const OllamaInsecureTransportError = LocalProviderInsecureTransportError;
+/**
+* Wrapped HTTP error returned by an adapter. Carries the original
+* status code so middleware (`withRetry`, `withFallback`) can decide
+* whether the error is retryable.
+*
+* @stable
+*/
+var ProviderHttpError = class extends GraphorinProviderError {
+	name = "ProviderHttpError";
+	status;
+	providerName;
+	constructor(args) {
+		super("provider-http", `[${args.providerName}] HTTP ${args.status}: ${args.message}`, { ...args.cause !== void 0 ? { cause: args.cause } : {} });
+		this.providerName = args.providerName;
+		this.status = args.status;
+	}
+};
+/**
+* The streaming response did not match the documented wire format
+* (e.g. malformed SSE chunk, truncated JSON).
+*
+* @stable
+*/
+var ProviderStreamParseError = class extends GraphorinProviderError {
+	name = "ProviderStreamParseError";
+	providerName;
+	constructor(providerName, message, cause) {
+		super("provider-stream-parse", `[${providerName}] ${message}`, { ...cause !== void 0 ? { cause } : {} });
+		this.providerName = providerName;
+	}
+};
+/**
+* The classifier dispatcher was given a non-Provider value. Programming
+* error; fail-fast at the boundary.
+*
+* @stable
+*/
+var InvalidProviderError = class extends GraphorinProviderError {
+	name = "InvalidProviderError";
+	constructor(message) {
+		super("invalid-provider", message, { hint: "Pass the value returned by createProvider(...) (or any adapter factory) instead of a raw object." });
+	}
+};
+
+//#endregion
+export { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError };
+//# sourceMappingURL=errors.js.map

package/dist/errors/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/errors/errors.ts"],"sourcesContent":["/**\n * Typed error hierarchy for `@graphorin/provider`. Every error class\n * carries a stable `kind` discriminant (lowercase, kebab-case) plus an\n * optional `hint` string pointing the user at the recommended fix.\n *\n * @packageDocumentation\n */\n\n/**\n * Base class for every error thrown by `@graphorin/provider`. Consumers\n * narrow on the discriminant `kind` rather than `instanceof` — both\n * work, but discriminants are subclass-friendly.\n *\n * @stable\n */\nexport class GraphorinProviderError extends Error {\n  override readonly name: string = 'GraphorinProviderError';\n  /** Stable discriminant — `'middleware-ordering'`, `'rate-limit-exceeded'`, … */\n  readonly kind: string;\n  /** Optional remediation hint shown alongside the message. */\n  readonly hint?: string;\n\n  constructor(kind: string, message: string, options?: { cause?: unknown; hint?: string }) {\n    super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);\n    this.kind = kind;\n    if (options?.hint !== undefined) {\n      this.hint = options.hint;\n    }\n  }\n}\n\n/**\n * The middleware composer detected an out-of-order middleware. The\n * `offendingPair` field carries the `[outer, inner]` middleware names\n * that violated the canonical order so consumers can surface a precise\n * fix in IDE diagnostics.\n *\n * @stable\n */\nexport class MiddlewareOrderingError extends GraphorinProviderError {\n  override readonly name = 'MiddlewareOrderingError';\n  readonly offendingPair: readonly [string, string];\n  readonly canonicalOrder: readonly string[];\n\n  constructor(args: {\n    offendingPair: readonly [string, string];\n    canonicalOrder: readonly string[];\n    message?: string;\n  }) {\n    super(\n      'middleware-ordering',\n      args.message ??\n        `Middleware order violation: '${args.offendingPair[0]}' must not wrap '${args.offendingPair[1]}'. ` +\n          `Canonical order (outer → inner): ${args.canonicalOrder.join(' → ')}.`,\n      {\n        hint:\n          'Reorder the middleware array passed to composeProviderMiddleware([...]) to match the canonical order; ' +\n          'see @graphorin/provider/middleware for documentation.',\n      },\n    );\n    this.offendingPair = args.offendingPair;\n    this.canonicalOrder = args.canonicalOrder;\n  }\n}\n\n/**\n * `withRedaction` was missing at production startup. Thrown by the\n * production hook applied to every composed provider when\n * `process.env.NODE_ENV === 'production'`.\n *\n * @stable\n */\nexport class MissingProductionMiddlewareError extends GraphorinProviderError {\n  override readonly name = 'MissingProductionMiddlewareError';\n  readonly missing: string;\n\n  constructor(missing: string) {\n    super(\n      'missing-production-middleware',\n      `Production startup hook: required middleware '${missing}' is missing from the provider chain.`,\n      {\n        hint:\n          `Compose '${missing}' as the innermost layer (closest to the underlying provider) before deploying. ` +\n          'See @graphorin/provider/middleware for the canonical composition order.',\n      },\n    );\n    this.missing = missing;\n  }\n}\n\n/**\n * `withCostLimit` exceeded its configured ceiling. Carries the\n * triggering scope (`session`, `agent`, `run`, …) so the caller can\n * decide how to surface the breach.\n *\n * @stable\n */\nexport class CostBudgetExceededError extends GraphorinProviderError {\n  override readonly name = 'CostBudgetExceededError';\n  readonly scope: string;\n  readonly limit: number;\n  readonly observed: number;\n\n  constructor(args: { scope: string; limit: number; observed: number; currency?: string }) {\n    super(\n      'cost-budget-exceeded',\n      `Cost budget exceeded for '${args.scope}': observed ${args.observed.toFixed(4)} ${args.currency ?? 'USD'} ` +\n        `> limit ${args.limit.toFixed(4)} ${args.currency ?? 'USD'}.`,\n      {\n        hint: 'Raise the limit in withCostLimit({...}), tighten the prompt, or switch to a cheaper model tier.',\n      },\n    );\n    this.scope = args.scope;\n    this.limit = args.limit;\n    this.observed = args.observed;\n  }\n}\n\n/**\n * `withRateLimit` exhausted its bucket and the caller did not opt\n * into `'queue'` mode.\n *\n * @stable\n */\nexport class RateLimitExceededError extends GraphorinProviderError {\n  override readonly name = 'RateLimitExceededError';\n  readonly retryAfterMs: number;\n\n  constructor(retryAfterMs: number) {\n    super('rate-limit-exceeded', `Rate limit exceeded; retry after ${retryAfterMs}ms.`, {\n      hint: 'Slow down the request rate, raise the bucket size in withRateLimit({...}), or switch to mode: \"queue\".',\n    });\n    this.retryAfterMs = retryAfterMs;\n  }\n}\n\n/**\n * `withRedaction` detected a hit AND the policy is configured for\n * `failClosed: true`. The matched value is **never** part of the\n * message — only the pattern name and field path.\n *\n * @stable\n */\nexport class PromptRedactionError extends GraphorinProviderError {\n  override readonly name = 'PromptRedactionError';\n  readonly patternName: string;\n  readonly fieldPath: string;\n  readonly role?: string;\n\n  constructor(args: { patternName: string; fieldPath: string; role?: string }) {\n    super(\n      'prompt-redaction-fail-closed',\n      `Outbound prompt-redaction policy is fail-closed and matched pattern '${args.patternName}' ` +\n        `at '${args.fieldPath}'${args.role ? ` (role: ${args.role})` : ''}.`,\n      {\n        hint: 'Sanitize the prompt before calling the provider, or disable failClosed in withRedaction({...}) for this environment.',\n      },\n    );\n    this.patternName = args.patternName;\n    this.fieldPath = args.fieldPath;\n    if (args.role !== undefined) this.role = args.role;\n  }\n}\n\n/**\n * Raised when a `baseUrl`-driven local adapter is configured against\n * a public host over plaintext HTTP. Adapters refuse to start unless\n * `allowInsecureTransport: true` is supplied (and the override is\n * audit-logged).\n *\n * @stable\n */\nexport class LocalProviderInsecureTransportError extends GraphorinProviderError {\n  override readonly name = 'LocalProviderInsecureTransportError';\n  readonly baseUrl: string;\n\n  constructor(baseUrl: string) {\n    super(\n      'local-provider-insecure-transport',\n      `Refusing to start: the provider baseUrl '${baseUrl}' is public AND plaintext (http://). ` +\n        `Switch to https:// or set allowInsecureTransport: true to acknowledge the risk.`,\n      {\n        hint:\n          'Public local-LLM endpoints must be served over TLS. Acceptable alternatives: terminate TLS in front of the model server, ' +\n          'tunnel through SSH / WireGuard / Tailscale, or pass allowInsecureTransport: true (audit-logged).',\n      },\n    );\n    this.baseUrl = baseUrl;\n  }\n}\n\n/**\n * Legacy alias preserved for one minor; prefer\n * {@link LocalProviderInsecureTransportError}. Removed in v0.2.\n *\n * @deprecated Use {@link LocalProviderInsecureTransportError} instead.\n */\nexport const OllamaInsecureTransportError = LocalProviderInsecureTransportError;\nexport type OllamaInsecureTransportError = LocalProviderInsecureTransportError;\n\n/**\n * Wrapped HTTP error returned by an adapter. Carries the original\n * status code so middleware (`withRetry`, `withFallback`) can decide\n * whether the error is retryable.\n *\n * @stable\n */\nexport class ProviderHttpError extends GraphorinProviderError {\n  override readonly name = 'ProviderHttpError';\n  readonly status: number;\n  readonly providerName: string;\n\n  constructor(args: { providerName: string; status: number; message: string; cause?: unknown }) {\n    super('provider-http', `[${args.providerName}] HTTP ${args.status}: ${args.message}`, {\n      ...(args.cause !== undefined ? { cause: args.cause } : {}),\n    });\n    this.providerName = args.providerName;\n    this.status = args.status;\n  }\n}\n\n/**\n * The streaming response did not match the documented wire format\n * (e.g. malformed SSE chunk, truncated JSON).\n *\n * @stable\n */\nexport class ProviderStreamParseError extends GraphorinProviderError {\n  override readonly name = 'ProviderStreamParseError';\n  readonly providerName: string;\n\n  constructor(providerName: string, message: string, cause?: unknown) {\n    super('provider-stream-parse', `[${providerName}] ${message}`, {\n      ...(cause !== undefined ? { cause } : {}),\n    });\n    this.providerName = providerName;\n  }\n}\n\n/**\n * The classifier dispatcher was given a non-Provider value. Programming\n * error; fail-fast at the boundary.\n *\n * @stable\n */\nexport class InvalidProviderError extends GraphorinProviderError {\n  override readonly name = 'InvalidProviderError';\n\n  constructor(message: string) {\n    super('invalid-provider', message, {\n      hint: 'Pass the value returned by createProvider(...) (or any adapter factory) instead of a raw object.',\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+import { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError } from "./errors.js";
+export { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError };

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+import { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError } from "./errors.js";
+
+export { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError };

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { LlamaCppServerAdapterOptions, llamaCppServerAdapter } from "./adapters/llamacpp-server.js";
+import { OllamaAdapterOptions, ollamaAdapter } from "./adapters/ollama.js";
+import { OpenAICompatibleAdapterOptions, openAICompatibleAdapter } from "./adapters/openai-compatible.js";
+import { VercelAdapterOptions, vercelAdapter } from "./adapters/vercel.js";
+import { AnthropicAPICounter, AnthropicAPICounterOptions } from "./counters/anthropic.js";
+import { BedrockAPICounter, BedrockAPICounterOptions } from "./counters/bedrock.js";
+import { CreateDefaultCounterOptions, createDefaultCounter } from "./counters/dispatcher.js";
+import { __resetGlobalTokenCounter, getGlobalTokenCounter, setGlobalTokenCounter } from "./counters/global.js";
+import { GoogleAPICounter, GoogleAPICounterOptions } from "./counters/google.js";
+import { HeuristicCounter, HeuristicCounterOptions } from "./counters/heuristic.js";
+import { JsTiktokenCounter, JsTiktokenCounterOptions, __resetTiktokenCache } from "./counters/js-tiktoken.js";
+import { SerializedMessage, serialiseMessageForCount, serializedToString } from "./counters/serialize.js";
+import "./counters/index.js";
+import { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError } from "./errors/errors.js";
+import "./adapters/index.js";
+import { CANONICAL_MIDDLEWARE_ORDER, MIDDLEWARE_KIND, composeProviderMiddleware, defineProviderMiddleware, getMiddlewareKind, providerHasMiddleware } from "./middleware/compose.js";
+import { ProductionStartupHookOptions, assertProductionMiddleware } from "./middleware/production-hook.js";
+import { WithCostLimitOptions, withCostLimit } from "./middleware/with-cost-limit.js";
+import { CostAccumulator, CostTrackingTotals, WithCostTrackingOptions, createCostAccumulator, withCostTracking } from "./middleware/with-cost-tracking.js";
+import { WithFallbackOptions, withFallback } from "./middleware/with-fallback.js";
+import { WithRateLimitOptions, withRateLimit } from "./middleware/with-rate-limit.js";
+import { PromptRedactionPolicy, PromptRedactionScanScope, PromptRedactionViolation, withRedaction } from "./middleware/with-redaction.js";
+import { WithRetryOptions, withRetry } from "./middleware/with-retry.js";
+import { WithTracingOptions, withTracing } from "./middleware/with-tracing.js";
+import "./middleware/index.js";
+import { CLASSIFIER_RULES, ClassifierRule, classifyModelTier } from "./model-tier/classify.js";
+import "./model-tier/index.js";
+import { CreateProviderOptions, createProvider } from "./provider.js";
+import { ApplyReasoningPolicyInput, applyReasoningPolicy } from "./reasoning/apply-policy.js";
+import { InferReasoningContractInput, REASONING_CONTRACT_RULES, ReasoningContractRule, inferReasoningContract } from "./reasoning/classify-contract.js";
+import { REASONING_RETENTION_DEFAULTS, ResolveReasoningRetentionInput, resolveReasoningRetention } from "./reasoning/retention.js";
+import "./reasoning/index.js";
+import { foldToolExamples } from "./tool-examples.js";
+import { LocalProviderClassification, PERMANENT_LOOPBACK_CLASSIFICATION, SENSITIVITY_DEFAULTS_PER_TRUST, classifyLocalProvider } from "./trust/classify-local-provider.js";
+import { LocalProviderTrust, OllamaTrust } from "./trust/index.js";
+
+//#region src/index.d.ts
+/**
+ * @graphorin/provider — vendor-neutral LLM provider layer for the
+ * Graphorin framework.
+ *
+ * The package owns:
+ *
+ * - The `createProvider(...)` factory for wrapping adapter modules in
+ *   a stable `Provider` shape.
+ * - Four adapters out of the box: the Vercel AI SDK adapter for the
+ *   default cloud path, plus three local-LLM adapters (Ollama HTTP,
+ *   llama-server HTTP, and a generic OpenAI-compatible adapter for
+ *   LMStudio / LocalAI / vLLM / Together-style endpoints). All three
+ *   `baseUrl`-driven adapters share the same {@link LocalProviderTrust}
+ *   classifier.
+ * - The canonical-order middleware composer
+ *   ({@link composeProviderMiddleware}) and the seven built-in
+ *   middlewares (`withTracing`, `withRetry`, `withRateLimit`,
+ *   `withCostLimit`, `withCostTracking`, `withFallback`,
+ *   `withRedaction`).
+ * - The pluggable `TokenCounter` dispatcher (`createDefaultCounter`)
+ *   plus the per-vendor strategies and a heuristic fallback.
+ * - The per-provider model-tier auto-classifier
+ *   ({@link classifyModelTier}) that maps a `Provider`'s `modelId` to
+ *   one of `'fast' | 'balanced' | 'smart'`.
+ *
+ * @packageDocumentation
+ */
+/** Canonical version constant. Mirrors the `package.json` version. */
+declare const VERSION = "0.5.0";
+//#endregion
+export { AnthropicAPICounter, AnthropicAPICounterOptions, ApplyReasoningPolicyInput, BedrockAPICounter, BedrockAPICounterOptions, CANONICAL_MIDDLEWARE_ORDER, CLASSIFIER_RULES, ClassifierRule, CostAccumulator, CostBudgetExceededError, CostTrackingTotals, CreateDefaultCounterOptions, CreateProviderOptions, GoogleAPICounter, GoogleAPICounterOptions, GraphorinProviderError, HeuristicCounter, HeuristicCounterOptions, InferReasoningContractInput, InvalidProviderError, JsTiktokenCounter, JsTiktokenCounterOptions, LlamaCppServerAdapterOptions, LocalProviderClassification, LocalProviderInsecureTransportError, LocalProviderTrust, MIDDLEWARE_KIND, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaAdapterOptions, OllamaInsecureTransportError, OllamaTrust, OpenAICompatibleAdapterOptions, PERMANENT_LOOPBACK_CLASSIFICATION, ProductionStartupHookOptions, PromptRedactionError, PromptRedactionPolicy, PromptRedactionScanScope, PromptRedactionViolation, ProviderHttpError, ProviderStreamParseError, REASONING_CONTRACT_RULES, REASONING_RETENTION_DEFAULTS, RateLimitExceededError, ReasoningContractRule, ResolveReasoningRetentionInput, SENSITIVITY_DEFAULTS_PER_TRUST, SerializedMessage, VERSION, VercelAdapterOptions, WithCostLimitOptions, WithCostTrackingOptions, WithFallbackOptions, WithRateLimitOptions, WithRetryOptions, WithTracingOptions, __resetGlobalTokenCounter, __resetTiktokenCache, applyReasoningPolicy, assertProductionMiddleware, classifyLocalProvider, classifyModelTier, composeProviderMiddleware, createCostAccumulator, createDefaultCounter, createProvider, defineProviderMiddleware, foldToolExamples, getGlobalTokenCounter, getMiddlewareKind, inferReasoningContract, llamaCppServerAdapter, ollamaAdapter, openAICompatibleAdapter, providerHasMiddleware, resolveReasoningRetention, serialiseMessageForCount, serializedToString, setGlobalTokenCounter, vercelAdapter, withCostLimit, withCostTracking, withFallback, withRateLimit, withRedaction, withRetry, withTracing };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6Ba,OAAA"}

package/dist/index.js

@@ -0,0 +1,70 @@
+import { CostBudgetExceededError, GraphorinProviderError, InvalidProviderError, LocalProviderInsecureTransportError, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, RateLimitExceededError } from "./errors/errors.js";
+import { applyReasoningPolicy } from "./reasoning/apply-policy.js";
+import { REASONING_RETENTION_DEFAULTS, resolveReasoningRetention } from "./reasoning/retention.js";
+import { PERMANENT_LOOPBACK_CLASSIFICATION, SENSITIVITY_DEFAULTS_PER_TRUST, classifyLocalProvider } from "./trust/classify-local-provider.js";
+import { llamaCppServerAdapter } from "./adapters/llamacpp-server.js";
+import { ollamaAdapter } from "./adapters/ollama.js";
+import { openAICompatibleAdapter } from "./adapters/openai-compatible.js";
+import { REASONING_CONTRACT_RULES, inferReasoningContract } from "./reasoning/classify-contract.js";
+import { vercelAdapter } from "./adapters/vercel.js";
+import "./adapters/index.js";
+import { serialiseMessageForCount, serializedToString } from "./counters/serialize.js";
+import { JsTiktokenCounter, __resetTiktokenCache } from "./counters/js-tiktoken.js";
+import { AnthropicAPICounter } from "./counters/anthropic.js";
+import { BedrockAPICounter } from "./counters/bedrock.js";
+import { GoogleAPICounter } from "./counters/google.js";
+import { HeuristicCounter } from "./counters/heuristic.js";
+import { createDefaultCounter } from "./counters/dispatcher.js";
+import { __resetGlobalTokenCounter, getGlobalTokenCounter, setGlobalTokenCounter } from "./counters/global.js";
+import "./counters/index.js";
+import { CANONICAL_MIDDLEWARE_ORDER, MIDDLEWARE_KIND, composeProviderMiddleware, defineProviderMiddleware, getMiddlewareKind, providerHasMiddleware } from "./middleware/compose.js";
+import { assertProductionMiddleware } from "./middleware/production-hook.js";
+import { withCostLimit } from "./middleware/with-cost-limit.js";
+import { createCostAccumulator, withCostTracking } from "./middleware/with-cost-tracking.js";
+import { withFallback } from "./middleware/with-fallback.js";
+import { withRateLimit } from "./middleware/with-rate-limit.js";
+import { withRedaction } from "./middleware/with-redaction.js";
+import { withRetry } from "./middleware/with-retry.js";
+import { withTracing } from "./middleware/with-tracing.js";
+import "./middleware/index.js";
+import { CLASSIFIER_RULES, classifyModelTier } from "./model-tier/classify.js";
+import "./model-tier/index.js";
+import { foldToolExamples } from "./tool-examples.js";
+import { createProvider } from "./provider.js";
+import "./reasoning/index.js";
+import "./trust/index.js";
+
+//#region src/index.ts
+/**
+* @graphorin/provider — vendor-neutral LLM provider layer for the
+* Graphorin framework.
+*
+* The package owns:
+*
+* - The `createProvider(...)` factory for wrapping adapter modules in
+*   a stable `Provider` shape.
+* - Four adapters out of the box: the Vercel AI SDK adapter for the
+*   default cloud path, plus three local-LLM adapters (Ollama HTTP,
+*   llama-server HTTP, and a generic OpenAI-compatible adapter for
+*   LMStudio / LocalAI / vLLM / Together-style endpoints). All three
+*   `baseUrl`-driven adapters share the same {@link LocalProviderTrust}
+*   classifier.
+* - The canonical-order middleware composer
+*   ({@link composeProviderMiddleware}) and the seven built-in
+*   middlewares (`withTracing`, `withRetry`, `withRateLimit`,
+*   `withCostLimit`, `withCostTracking`, `withFallback`,
+*   `withRedaction`).
+* - The pluggable `TokenCounter` dispatcher (`createDefaultCounter`)
+*   plus the per-vendor strategies and a heuristic fallback.
+* - The per-provider model-tier auto-classifier
+*   ({@link classifyModelTier}) that maps a `Provider`'s `modelId` to
+*   one of `'fast' | 'balanced' | 'smart'`.
+*
+* @packageDocumentation
+*/
+/** Canonical version constant. Mirrors the `package.json` version. */
+const VERSION = "0.5.0";
+
+//#endregion
+export { AnthropicAPICounter, BedrockAPICounter, CANONICAL_MIDDLEWARE_ORDER, CLASSIFIER_RULES, CostBudgetExceededError, GoogleAPICounter, GraphorinProviderError, HeuristicCounter, InvalidProviderError, JsTiktokenCounter, LocalProviderInsecureTransportError, MIDDLEWARE_KIND, MiddlewareOrderingError, MissingProductionMiddlewareError, OllamaInsecureTransportError, PERMANENT_LOOPBACK_CLASSIFICATION, PromptRedactionError, ProviderHttpError, ProviderStreamParseError, REASONING_CONTRACT_RULES, REASONING_RETENTION_DEFAULTS, RateLimitExceededError, SENSITIVITY_DEFAULTS_PER_TRUST, VERSION, __resetGlobalTokenCounter, __resetTiktokenCache, applyReasoningPolicy, assertProductionMiddleware, classifyLocalProvider, classifyModelTier, composeProviderMiddleware, createCostAccumulator, createDefaultCounter, createProvider, defineProviderMiddleware, foldToolExamples, getGlobalTokenCounter, getMiddlewareKind, inferReasoningContract, llamaCppServerAdapter, ollamaAdapter, openAICompatibleAdapter, providerHasMiddleware, resolveReasoningRetention, serialiseMessageForCount, serializedToString, setGlobalTokenCounter, vercelAdapter, withCostLimit, withCostTracking, withFallback, withRateLimit, withRedaction, withRetry, withTracing };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * @graphorin/provider — vendor-neutral LLM provider layer for the\n * Graphorin framework.\n *\n * The package owns:\n *\n * - The `createProvider(...)` factory for wrapping adapter modules in\n *   a stable `Provider` shape.\n * - Four adapters out of the box: the Vercel AI SDK adapter for the\n *   default cloud path, plus three local-LLM adapters (Ollama HTTP,\n *   llama-server HTTP, and a generic OpenAI-compatible adapter for\n *   LMStudio / LocalAI / vLLM / Together-style endpoints). All three\n *   `baseUrl`-driven adapters share the same {@link LocalProviderTrust}\n *   classifier.\n * - The canonical-order middleware composer\n *   ({@link composeProviderMiddleware}) and the seven built-in\n *   middlewares (`withTracing`, `withRetry`, `withRateLimit`,\n *   `withCostLimit`, `withCostTracking`, `withFallback`,\n *   `withRedaction`).\n * - The pluggable `TokenCounter` dispatcher (`createDefaultCounter`)\n *   plus the per-vendor strategies and a heuristic fallback.\n * - The per-provider model-tier auto-classifier\n *   ({@link classifyModelTier}) that maps a `Provider`'s `modelId` to\n *   one of `'fast' | 'balanced' | 'smart'`.\n *\n * @packageDocumentation\n */\n\n/** Canonical version constant. Mirrors the `package.json` version. */\nexport const VERSION = '0.5.0';\n\nexport * from './adapters/index.js';\nexport * from './counters/index.js';\nexport * from './errors/index.js';\nexport * from './middleware/index.js';\nexport * from './model-tier/index.js';\nexport * from './provider.js';\nexport * from './reasoning/index.js';\nexport { foldToolExamples } from './tool-examples.js';\nexport * from './trust/index.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,UAAU"}