@sigrun/provider-pareto 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.1] - 2026-10-27
+### Changed
+- Re-released through CI trusted publishing; this version carries SLSA
+  provenance. No functional change from 0.1.0.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-18
+### Changed
+- Renamed to `@sigrun/provider-pareto` for the 0.1.0 release (GitHub
+  repo `sigrun-ai/sigrun-provider-pareto`): published package metadata
+  (`publishConfig` access/provenance), host modules
+  (`@earendil-works/pi-ai`, `@earendil-works/pi-durable`) moved to
+  `peerDependencies` mirrored in `devDependencies` at exact `1.3.0`,
+  CHANGELOG.md joined the files whitelist, and a manifest hygiene check
+  wired into `npm test`.
+### Added
+- Sigrun provider plugin: Pareto paygo
+  (`https://api.paretoinference.com/v1`, live-verified 2026-10-18) as
+  one dynamic OpenAI-compatible provider (`provider: "pareto"` stamped
+  on every catalog entry so persisted catalogs survive cold-boot
+  restore).
+- Provider-only contributor factory: `{ name: "provider-pareto",
+  providers: [{ provider, readiness }], health }` — no pi-durable
+  extension surface.
+- Deployment-configurable base URL: the async factory reads `baseUrl`
+  from the plugin's scoped settings with the constant as fallback; a
+  malformed override fails the factory loudly instead of silently
+  falling back.
+- Credential resolution through sigrun's auth.json bridge with
+  `PARETO_API_KEY` as the ambient fallback (bridge credential always
+  wins).
+- Three-state readiness tracker (`not_configured` / `degraded` /
+  `ready`) seeded from credential resolution and updated per refresh
+  outcome; `console.warn` on state transitions only. `health()` maps
+  `not_configured` to `"ok"` and configured-and-failing to
+  `"degraded"`.
+- `fetchModels` throws on unconfigured and on failure — never returns
+  `[]` (an empty array would publish and wipe the persisted catalog).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael MacLeod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,93 @@
-# Temporary Holding Version
+# @sigrun/provider-pareto
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A [sigrun](https://github.com/sigrun-ai) provider plugin:
+[Pareto](https://paretoinference.com) paygo (OpenAI-compatible
+inference) as one dynamic chat provider.
+
+## What it contributes
+
+A **provider-only contributor** — the default export is a factory
+returning `{ name: "provider-pareto", providers: [{ provider, readiness }],
+health }` with no pi-durable extension surface. Sigrun's loader merges
+the provider into its `Models` store at boot.
+
+- **Provider** `pareto` — dynamic catalog fetched from `<base>/models`
+  (OpenAI `[OI]` list shape; entries also carry a per-token dollar-string
+  `pricing` object this plugin does not map — cost stays zeroed and
+  structural) over `openai-completions`; boots with an empty baseline
+  and publishes the fetched catalog.
+- **Readiness** (`not_configured` / `degraded` / `ready`, surfaced on
+  sigrun's `/v1/auth/check`) — seeded from credential resolution and
+  updated per refresh outcome; state transitions log via `console.warn`
+  (transitions only, never per failure). On the first configured boot
+  the provider announces `startup → ready` at credential *resolution* —
+  before any refresh has run (`ready` there means "credential resolved,
+  refresh not yet attempted", not "catalog verified").
+- **Health** — `degraded` only when the provider is configured and its
+  last refresh failed; an unconfigured optional plugin reports `ok`.
+
+## Base URL
+
+The default endpoint constant is `https://api.paretoinference.com/v1`
+(live-verified 2026-10-18). Pareto's documented base URL is a
+deployment-specific value, so the factory reads the plugin's scoped
+settings first — `baseUrl` (string) in `settings/provider-pareto.json`
+overrides the constant:
+
+```jsonc
+// settings/provider-pareto.json (in the sigrun config dir)
+{ "baseUrl": "https://your-pareto-endpoint.example/v1" }
+```
+
+An absent `baseUrl` uses the constant; a present-but-malformed one
+(empty or not a string) fails the factory loudly (the extension
+quarantines with the reason) rather than silently falling back.
+
+## Credentials
+
+Resolved per request through sigrun's auth.json bridge, falling back to
+the ambient environment:
+
+1. the bridged auth.json credential (`"default"` entry, then the
+   `"pareto"` entry), then
+2. `PARETO_API_KEY`.
+
+The plugin never reads auth.json or `process.env` itself. Rotating the
+key applies on the next resolution — no restart needed.
+
+## Failure semantics
+
+`fetchModels` **throws** when unconfigured or when the catalog fetch
+fails — it never returns an empty array, which pi-ai would publish and
+persist, wiping the catalog. A failed refresh retains the previous
+catalog and records a per-provider error.
+
+## Install
+
+```jsonc
+// settings.json (sigrun config dir) — the UNIFIED extensions list:
+// install + load in one place; npm and git specifiers are the same list
+// npm ("@sigrun/provider-pareto@^0.1.0"), git
+// ("git:github.com/sigrun-ai/sigrun-provider-pareto", or any
+// https git URL with an optional @ref), or the file: form below.
+{
+	"extensions": ["file:/path/to/sigrun-pareto"]
+}
+```
+
+The committed `dist/` is the load target for git installs; pi-ai and
+pi-durable are peerDependencies (sigrun supplies them at runtime);
+they are mirrored in devDependencies for this repo's own build and tests.
+
+## Development
+
+```sh
+npm install        # also builds dist/ via prepare
+npm test           # vitest — hermetic fixture HTTP server, no network
+npm run typecheck
+npm run build
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @sigrun/provider-pareto — a sigrun provider plugin (provider plugins Task 9):
+ * [Pareto](https://paretoinference.com) paygo (OpenAI-compatible
+ * inference) as one dynamic provider.
+ *
+ * Structurally identical to sigrun-ollama (the Task 7 reference plugin):
+ * the default export is the sigrun extension-package factory returning a
+ * PROVIDER-ONLY contributor — `{ name, providers, health }` with no
+ * `extension` field — consumed structurally by sigrun's loader. The
+ * deltas from the reference are the provider id, the base URL, the
+ * ambient env key, and ONE addition: the base URL is
+ * deployment-configurable through the plugin's scoped settings
+ * (`baseUrl` in `settings/provider-pareto.json`, constant fallback),
+ * because Pareto's documented endpoint is a deployment-specific value.
+ * Credentials resolve through sigrun's auth.json bridge (the stored
+ * credential arrives as `credential` on the auth resolver, ambient env
+ * as `ctx.env`) with `PARETO_API_KEY` as the fallback; the plugin never
+ * reads auth.json or `process.env` itself.
+ *
+ * Runtime imports from pi-ai are deliberate (`createProvider` + the
+ * OpenAI-completions api); the package still declares pi-ai/pi-durable as
+ * devDependencies only, because sigrun (the host) ships them and
+ * `syncPackages` installs with `--omit=dev` — the provider-plugins spec's
+ * dependency posture.
+ */
+import { type Provider } from "@earendil-works/pi-ai/models";
+import type { Model } from "@earendil-works/pi-ai";
+/** The provider id models are registered (and stamped) under. */
+export declare const PARETO_PROVIDER_ID = "pareto";
+/**
+ * Pareto's OpenAI-compatible endpoint. Live-verified 2026-10-18; the
+ * operator can override per deployment via the plugin's scoped settings
+ * (`baseUrl`) — see {@link resolveParetoBaseUrl}.
+ */
+export declare const PARETO_BASE_URL = "https://api.paretoinference.com/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export declare const PARETO_API_KEY_ENV = "PARETO_API_KEY";
+/**
+ * Structural slice of sigrun's seam host (src/harness/seam-host.ts) a
+ * provider plugin may consume. Declared here — structurally, like the
+ * bridge's pi-ai re-declarations — because the plugin cannot import
+ * sigrun core. The scoped settings store is async-only, which is why the
+ * loader awaits factory results (and why this plugin's factory is async).
+ */
+export interface SigrunPluginHost {
+    readonly stores: {
+        /** This plugin's own `settings/<slug>.json`; absent file → `{}`. */
+        readonly settings: {
+            get(): Promise<Record<string, unknown>>;
+            set(value: Record<string, unknown>): Promise<void>;
+        };
+    };
+}
+/** Sigrun's three-state per-provider readiness vocabulary (Task 6). */
+export type ProviderReadinessStatus = "not_configured" | "degraded" | "ready";
+/** One tracker report: the status plus optional operator-facing detail. */
+export interface ProviderReadiness {
+    readonly status: ProviderReadinessStatus;
+    readonly detail?: string;
+}
+/** Sigrun's §3 health vocabulary. */
+export type HealthStatus = "ok" | "degraded";
+/**
+ * The provider-plugin factory result (the loader's Task 1 contract):
+ * a provider-only contributor — `{ name, providers, health? }`, no
+ * `extension`. Structural, like the host slice above.
+ */
+export interface ProviderPluginResult {
+    readonly name: string;
+    readonly providers: readonly {
+        readonly provider: Provider;
+        readonly readiness?: () => ProviderReadiness;
+    }[];
+    readonly health?: () => HealthStatus;
+}
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link PARETO_BASE_URL} constant. Absent → the
+ * constant; present-but-not-a-non-empty-string → throw (a malformed
+ * override must quarantine loudly, not silently fall back to a possibly
+ * wrong constant).
+ */
+export declare function resolveParetoBaseUrl(settings: Record<string, unknown>): string;
+/**
+ * Parse an OpenAI-compatible `[OI]` `/models` body into pi-ai chat
+ * models. Every entry is stamped `provider: "pareto"` — pi-ai's restore
+ * path drops stored models whose `provider` field differs from the
+ * registered id, so an unstamped catalog silently vanishes on cold boot.
+ * Malformed bodies throw (a refresh failure retains the previous
+ * catalog; garbage must never publish). Extra entry fields (the live
+ * endpoint also serves `owned_by` and a `pricing` object) are ignored.
+ */
+export declare function parseParetoCatalog(body: unknown, baseUrl: string): Model<"openai-completions">[];
+/** One built plugin: the contribution's parts, sharing the tracker closure. */
+export interface ParetoPlugin {
+    readonly provider: Provider;
+    /** Synchronous read over plugin-owned state (never network/storage). */
+    readonly readiness: () => ProviderReadiness;
+    readonly health: () => HealthStatus;
+}
+/**
+ * Build the Pareto provider plus its readiness/health trackers.
+ * `baseUrl` is overridable (scoped settings in the default factory,
+ * fixture server in tests); the default is the live-verified endpoint.
+ */
+export declare function createParetoPlugin(baseUrl?: string): ParetoPlugin;
+/**
+ * The sigrun extension-package factory (provider-only contributor).
+ * Arity 1 declares the host-taking signature — sigrun's loader passes the
+ * seam host only to factories that declare one (`factory.length > 0`) —
+ * and the factory is ASYNC because the scoped settings store is
+ * async-only; sigrun's loader awaits factory results.
+ */
+export default function sigrunPareto(host: SigrunPluginHost): Promise<ProviderPluginResult>;

package/dist/index.js

@@ -0,0 +1,251 @@
+/**
+ * @sigrun/provider-pareto — a sigrun provider plugin (provider plugins Task 9):
+ * [Pareto](https://paretoinference.com) paygo (OpenAI-compatible
+ * inference) as one dynamic provider.
+ *
+ * Structurally identical to sigrun-ollama (the Task 7 reference plugin):
+ * the default export is the sigrun extension-package factory returning a
+ * PROVIDER-ONLY contributor — `{ name, providers, health }` with no
+ * `extension` field — consumed structurally by sigrun's loader. The
+ * deltas from the reference are the provider id, the base URL, the
+ * ambient env key, and ONE addition: the base URL is
+ * deployment-configurable through the plugin's scoped settings
+ * (`baseUrl` in `settings/provider-pareto.json`, constant fallback),
+ * because Pareto's documented endpoint is a deployment-specific value.
+ * Credentials resolve through sigrun's auth.json bridge (the stored
+ * credential arrives as `credential` on the auth resolver, ambient env
+ * as `ctx.env`) with `PARETO_API_KEY` as the fallback; the plugin never
+ * reads auth.json or `process.env` itself.
+ *
+ * Runtime imports from pi-ai are deliberate (`createProvider` + the
+ * OpenAI-completions api); the package still declares pi-ai/pi-durable as
+ * devDependencies only, because sigrun (the host) ships them and
+ * `syncPackages` installs with `--omit=dev` — the provider-plugins spec's
+ * dependency posture.
+ */
+import { createProvider } from "@earendil-works/pi-ai/models";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+/** The provider id models are registered (and stamped) under. */
+export const PARETO_PROVIDER_ID = "pareto";
+/**
+ * Pareto's OpenAI-compatible endpoint. Live-verified 2026-10-18; the
+ * operator can override per deployment via the plugin's scoped settings
+ * (`baseUrl`) — see {@link resolveParetoBaseUrl}.
+ */
+export const PARETO_BASE_URL = "https://api.paretoinference.com/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export const PARETO_API_KEY_ENV = "PARETO_API_KEY";
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link PARETO_BASE_URL} constant. Absent → the
+ * constant; present-but-not-a-non-empty-string → throw (a malformed
+ * override must quarantine loudly, not silently fall back to a possibly
+ * wrong constant).
+ */
+export function resolveParetoBaseUrl(settings) {
+    if (!("baseUrl" in settings))
+        return PARETO_BASE_URL;
+    const value = settings.baseUrl;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error("provider-pareto: settings/provider-pareto.json baseUrl must be a non-empty string when present");
+    }
+    return value.trim();
+}
+/**
+ * Conservative placeholders for catalog entries Pareto's `/models` shape
+ * gives no usable metadata for (entries carry a per-token `pricing`
+ * object in dollar STRINGS, which this plugin does not map — cost stays
+ * zeroed and structural until sigrun defines a rate source of truth).
+ * Same values as the reference plugin and sigrun's degenerate env
+ * provider, keeping context management deterministic against unknown
+ * windows.
+ */
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+/**
+ * Parse an OpenAI-compatible `[OI]` `/models` body into pi-ai chat
+ * models. Every entry is stamped `provider: "pareto"` — pi-ai's restore
+ * path drops stored models whose `provider` field differs from the
+ * registered id, so an unstamped catalog silently vanishes on cold boot.
+ * Malformed bodies throw (a refresh failure retains the previous
+ * catalog; garbage must never publish). Extra entry fields (the live
+ * endpoint also serves `owned_by` and a `pricing` object) are ignored.
+ */
+export function parseParetoCatalog(body, baseUrl) {
+    if (typeof body !== "object" || body === null) {
+        throw new Error("pareto /models body is not a JSON object");
+    }
+    const data = body.data;
+    if (!Array.isArray(data)) {
+        throw new Error("pareto /models body has no data array");
+    }
+    return data.map((entry) => {
+        const id = entry?.id;
+        if (typeof id !== "string" || id.length === 0) {
+            throw new Error("pareto /models entry without a string id");
+        }
+        const model = {
+            id,
+            name: id,
+            api: "openai-completions",
+            // THE stamp — see the doc comment above.
+            provider: PARETO_PROVIDER_ID,
+            baseUrl,
+            // Pareto's /models carries no modality metadata; text is the
+            // safe floor (claiming image without evidence would ship image
+            // parts to models that cannot read them).
+            input: ["text"],
+            // Rates exist on the wire but are not mapped (see the
+            // placeholders comment); zeroed, usage tracking stays
+            // structural.
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            reasoning: false,
+            contextWindow: DEFAULT_CONTEXT_WINDOW,
+            maxTokens: DEFAULT_MAX_TOKENS,
+        };
+        return model;
+    });
+}
+/**
+ * Build the Pareto provider plus its readiness/health trackers.
+ * `baseUrl` is overridable (scoped settings in the default factory,
+ * fixture server in tests); the default is the live-verified endpoint.
+ */
+export function createParetoPlugin(baseUrl = PARETO_BASE_URL) {
+    // Tracker state: seeded from credential resolution (pi-ai never
+    // refreshes an unconfigured provider, so refresh outcomes alone cannot
+    // express not_configured), updated per refresh outcome. Readiness and
+    // health are synchronous derivations over this state.
+    let credentialResolved = false;
+    let lastRefreshFailed = false;
+    let lastRefreshDetail;
+    let lastAnnounced;
+    function status() {
+        if (!credentialResolved)
+            return "not_configured";
+        return lastRefreshFailed ? "degraded" : "ready";
+    }
+    /** Apply a state change; `console.warn` on transitions only. */
+    function announce() {
+        const next = status();
+        if (next === lastAnnounced)
+            return;
+        console.warn(`provider-pareto: pareto ${lastAnnounced ?? "startup"} → ${next}` +
+            (lastRefreshDetail !== undefined && next === "degraded"
+                ? ` (${lastRefreshDetail})`
+                : ""));
+        lastAnnounced = next;
+    }
+    function noteCredential(resolved) {
+        credentialResolved = resolved;
+        announce();
+    }
+    function noteRefresh(ok, detail) {
+        lastRefreshFailed = !ok;
+        lastRefreshDetail = ok ? undefined : detail;
+        announce();
+    }
+    const provider = createProvider({
+        id: PARETO_PROVIDER_ID,
+        name: "Pareto",
+        baseUrl,
+        // REQUIRED baseline: createProvider iterates it (omitting throws
+        // "baselineModels is not iterable"); empty = purely dynamic.
+        models: [],
+        auth: {
+            apiKey: {
+                name: "Pareto API key (auth.json or PARETO_API_KEY)",
+                resolve: async ({ credential, ctx }) => {
+                    // Bridged auth.json credential (sigrun's bridge: the
+                    // "default" entry first, then the provider's own) wins;
+                    // the env var is the ambient fallback.
+                    const stored = credential?.key?.trim() || undefined;
+                    if (stored !== undefined) {
+                        noteCredential(true);
+                        return { auth: { apiKey: stored }, source: "auth.json" };
+                    }
+                    const envKey = (await ctx.env(PARETO_API_KEY_ENV))?.trim() || undefined;
+                    if (envKey !== undefined) {
+                        noteCredential(true);
+                        return { auth: { apiKey: envKey }, source: PARETO_API_KEY_ENV };
+                    }
+                    // Unconfigured: undefined makes pi-ai skip the refresh
+                    // phase entirely and requests fail loud.
+                    noteCredential(false);
+                    return undefined;
+                },
+            },
+        },
+        fetchModels: async (context) => {
+            // The context credential is whatever auth resolution produced —
+            // for this plugin always the merged api key; narrow rather than
+            // trust the union.
+            const key = context.credential?.type === "api_key"
+                ? context.credential.key?.trim() || undefined
+                : undefined;
+            if (key === undefined) {
+                noteCredential(false);
+                // NEVER return [] — the createProvider wrapper publishes +
+                // persists whatever fetchModels returns; an empty array
+                // would wipe the catalog.
+                throw new Error(`provider-pareto: Pareto is not configured ` +
+                    `(no auth.json credential and no ${PARETO_API_KEY_ENV}); ` +
+                    "refusing to publish an empty catalog");
+            }
+            const effectiveBase = context.baseUrl ?? baseUrl;
+            // URL-join needs the trailing slash ("models" against a
+            // slash-less base would resolve to the host root).
+            const root = effectiveBase.endsWith("/") ? effectiveBase : `${effectiveBase}/`;
+            try {
+                const response = await fetch(new URL("models", root), {
+                    headers: { Authorization: `Bearer ${key}` },
+                    signal: context.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const models = parseParetoCatalog(await response.json(), effectiveBase);
+                noteRefresh(true);
+                return models;
+            }
+            catch (cause) {
+                // An aborted refresh is not a failed one: pi-ai discards
+                // the outcome anyway, so the tracker must not move.
+                if (context.signal.aborted)
+                    throw cause;
+                const message = cause instanceof Error ? cause.message : String(cause);
+                noteRefresh(false, message);
+                throw new Error(`provider-pareto: Pareto catalog refresh failed: ${message}`);
+            }
+        },
+        api: openAICompletionsApi(),
+    });
+    return {
+        provider,
+        readiness: () => ({
+            status: status(),
+            ...(lastRefreshDetail !== undefined && status() === "degraded"
+                ? { detail: lastRefreshDetail }
+                : {}),
+        }),
+        // not_configured → ok (an unconfigured optional plugin is not a
+        // degraded process); configured-and-failing → degraded; else ok.
+        health: () => (status() === "degraded" ? "degraded" : "ok"),
+    };
+}
+/**
+ * The sigrun extension-package factory (provider-only contributor).
+ * Arity 1 declares the host-taking signature — sigrun's loader passes the
+ * seam host only to factories that declare one (`factory.length > 0`) —
+ * and the factory is ASYNC because the scoped settings store is
+ * async-only; sigrun's loader awaits factory results.
+ */
+export default async function sigrunPareto(host) {
+    const settings = await host.stores.settings.get();
+    const plugin = createParetoPlugin(resolveParetoBaseUrl(settings));
+    return {
+        name: "provider-pareto",
+        providers: [{ provider: plugin.provider, readiness: plugin.readiness }],
+        health: plugin.health,
+    };
+}

package/package.json

@@ -1,6 +1,51 @@
 {
-  "name": "@sigrun/provider-pareto",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@sigrun/provider-pareto",
+	"version": "0.1.1",
+	"description": "Sigrun provider plugin: Pareto paygo (OpenAI-compatible inference) as a dynamic provider",
+	"type": "module",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"test": "node scripts/check-manifest.mjs --expect-name @sigrun/provider-pareto && vitest run",
+		"typecheck": "tsc --noEmit",
+		"build": "tsc -p tsconfig.build.json",
+		"prepare": "npm run build"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "1.3.0",
+		"@earendil-works/pi-durable": "1.3.0",
+		"@types/node": "^26.6.4",
+		"typescript": "^7.0.2",
+		"vitest": "^5.0.3"
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "github",
+		"url": "git+https://github.com/sigrun-ai/sigrun-provider-pareto.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sigrun-ai/sigrun-provider-pareto/issues"
+	},
+	"homepage": "https://github.com/sigrun-ai/sigrun-provider-pareto#readme",
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "1.3.0",
+		"@earendil-works/pi-durable": "1.3.0"
+	}
+}