@sigrun/provider-opencode 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# 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-opencode` for the 0.1.0 release (GitHub
+  repo `sigrun-ai/sigrun-provider-opencode`): 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`. The contributor identity follows the package
+  slug: the factory result's `name` becomes `provider-opencode` and the
+  scoped settings file `settings/provider-opencode.json` (the loader
+  pre-keys the two-phase host from the package name; a stale declared
+  name would split the factory-time settings scope).
+### Added
+- Deployment-configurable base URL: the (now async) factory reads
+  `baseUrl` from the plugin's scoped settings
+  (`settings/provider-opencode.json`) with the constant as fallback; a
+  malformed override fails the factory loudly instead of silently
+  falling back (mirrors sigrun-pareto; restart-required).
+### Added
+- Sigrun provider plugin: OpenCode's paid Go tier
+  (`https://opencode.ai/zen/go/v1`) as one dynamic OpenAI-compatible
+  provider (`provider: "opencode"` stamped on every catalog entry so
+  persisted catalogs survive cold-boot restore). The `/zen/v1` free tier
+  is client-gated and out of scope.
+- Provider-only contributor factory: `{ name: "provider-opencode",
+  providers: [{ provider, readiness }], health }` — no pi-durable
+  extension surface.
+- Credential resolution through sigrun's auth.json bridge with
+  `OPENCODE_GO_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,79 @@
-# Temporary Holding Version
+# @sigrun/provider-opencode
 
-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:
+[OpenCode](https://opencode.ai)'s **paid Go tier**
+(`https://opencode.ai/zen/go/v1`, OpenAI-compatible) as one dynamic chat
+provider. The `/zen/v1` free tier is client-gated by design (FreeTierError
+for non-CLI requests) and is out of scope.
+
+## What it contributes
+
+A **provider-only contributor** — the default export is a factory
+returning `{ name: "provider-opencode", providers: [{ provider, readiness }],
+health }` with no pi-durable extension surface. Sigrun's loader merges
+the provider into its `Models` store at boot.
+
+- **Provider** `opencode` — dynamic catalog fetched from
+  `<base>/models` (OpenAI `[OI]` list shape; entries carry
+  `id`/`object`/`created`/`owned_by` and no capability metadata) 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`.
+
+## 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
+   `"opencode"` entry), then
+2. `OPENCODE_GO_API_KEY`.
+
+The plugin never reads auth.json or `process.env` itself. Rotating the
+key applies on the next resolution — no restart needed (there are no
+plugin settings; the endpoint is fixed).
+
+## 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-opencode@^0.1.0"), git
+// ("git:github.com/sigrun-ai/sigrun-provider-opencode", or any
+// https git URL with an optional @ref), or the file: form below.
+{
+	"extensions": ["file:/path/to/sigrun-opencode"]
+}
+```
+
+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,116 @@
+/**
+ * @sigrun/provider-opencode — a sigrun provider plugin (provider plugins Task 8):
+ * OpenCode's PAID Go tier (`https://opencode.ai/zen/go/v1`) as one
+ * dynamic OpenAI-compatible provider. The `/zen/v1` free tier is
+ * client-gated by design (FreeTierError for non-CLI requests) and is out
+ * of scope.
+ *
+ * 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 only
+ * intended deltas from the reference are the provider id, the base URL,
+ * and the ambient env key. Credentials resolve through sigrun's auth.json
+ * bridge (the stored credential arrives as `credential` on the auth
+ * resolver, ambient env as `ctx.env`) with `OPENCODE_GO_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 OPENCODE_PROVIDER_ID = "opencode";
+/**
+ * OpenCode's paid Go tier (OpenAI-compatible endpoint). The operator can
+ * override per deployment via the plugin's scoped settings (`baseUrl`) —
+ * see {@link resolveOpencodeBaseUrl}.
+ */
+export declare const OPENCODE_BASE_URL = "https://opencode.ai/zen/go/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export declare const OPENCODE_API_KEY_ENV = "OPENCODE_GO_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.
+ */
+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;
+}
+/**
+ * Parse an OpenAI-compatible `[OI]` `/models` body into pi-ai chat
+ * models. Every entry is stamped `provider: "opencode"` — 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 serves id/object/created/owned_by) are ignored.
+ */
+export declare function parseOpencodeCatalog(body: unknown, baseUrl: string): Model<"openai-completions">[];
+/** One built plugin: the contribution's parts, sharing the tracker closure. */
+export interface OpencodePlugin {
+    readonly provider: Provider;
+    /** Synchronous read over plugin-owned state (never network/storage). */
+    readonly readiness: () => ProviderReadiness;
+    readonly health: () => HealthStatus;
+}
+/**
+ * Build the OpenCode Go provider plus its readiness/health trackers.
+ * `baseUrl` is overridable so hermetic tests drive a fixture server; the
+ * default is the real Go-tier endpoint.
+ */
+export declare function createOpencodePlugin(baseUrl?: string): OpencodePlugin;
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link OPENCODE_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 resolveOpencodeBaseUrl(settings: Record<string, unknown>): string;
+/**
+ * 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. The base URL is
+ * deployment-configurable through the scoped settings (`baseUrl` in
+ * `settings/provider-opencode.json`, constant fallback): deployments behind
+ * a proxy or mirror — and hermetic test fixtures — redirect the endpoint
+ * that way (restart-required, exactly like sigrun-pareto/sigrun-bifrost).
+ */
+export default function sigrunOpencode(host: SigrunPluginHost): Promise<ProviderPluginResult>;

package/dist/index.js

@@ -0,0 +1,249 @@
+/**
+ * @sigrun/provider-opencode — a sigrun provider plugin (provider plugins Task 8):
+ * OpenCode's PAID Go tier (`https://opencode.ai/zen/go/v1`) as one
+ * dynamic OpenAI-compatible provider. The `/zen/v1` free tier is
+ * client-gated by design (FreeTierError for non-CLI requests) and is out
+ * of scope.
+ *
+ * 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 only
+ * intended deltas from the reference are the provider id, the base URL,
+ * and the ambient env key. Credentials resolve through sigrun's auth.json
+ * bridge (the stored credential arrives as `credential` on the auth
+ * resolver, ambient env as `ctx.env`) with `OPENCODE_GO_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 OPENCODE_PROVIDER_ID = "opencode";
+/**
+ * OpenCode's paid Go tier (OpenAI-compatible endpoint). The operator can
+ * override per deployment via the plugin's scoped settings (`baseUrl`) —
+ * see {@link resolveOpencodeBaseUrl}.
+ */
+export const OPENCODE_BASE_URL = "https://opencode.ai/zen/go/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export const OPENCODE_API_KEY_ENV = "OPENCODE_GO_API_KEY";
+/**
+ * Conservative placeholders for catalog entries the Go tier's `/models`
+ * shape gives no metadata for (no window, no limits, no rates — entries
+ * carry only id/object/created/owned_by). 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: "opencode"` — 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 serves id/object/created/owned_by) are ignored.
+ */
+export function parseOpencodeCatalog(body, baseUrl) {
+    if (typeof body !== "object" || body === null) {
+        throw new Error("opencode /models body is not a JSON object");
+    }
+    const data = body.data;
+    if (!Array.isArray(data)) {
+        throw new Error("opencode /models body has no data array");
+    }
+    return data.map((entry) => {
+        const id = entry?.id;
+        if (typeof id !== "string" || id.length === 0) {
+            throw new Error("opencode /models entry without a string id");
+        }
+        const model = {
+            id,
+            name: id,
+            api: "openai-completions",
+            // THE stamp — see the doc comment above.
+            provider: OPENCODE_PROVIDER_ID,
+            baseUrl,
+            // The Go tier'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"],
+            // Unknown rates: 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 OpenCode Go provider plus its readiness/health trackers.
+ * `baseUrl` is overridable so hermetic tests drive a fixture server; the
+ * default is the real Go-tier endpoint.
+ */
+export function createOpencodePlugin(baseUrl = OPENCODE_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-opencode: opencode ${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: OPENCODE_PROVIDER_ID,
+        name: "OpenCode Go",
+        baseUrl,
+        // REQUIRED baseline: createProvider iterates it (omitting throws
+        // "baselineModels is not iterable"); empty = purely dynamic.
+        models: [],
+        auth: {
+            apiKey: {
+                name: "OpenCode Go API key (auth.json or OPENCODE_GO_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(OPENCODE_API_KEY_ENV))?.trim() || undefined;
+                    if (envKey !== undefined) {
+                        noteCredential(true);
+                        return { auth: { apiKey: envKey }, source: OPENCODE_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-opencode: OpenCode Go is not configured ` +
+                    `(no auth.json credential and no ${OPENCODE_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 = parseOpencodeCatalog(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-opencode: OpenCode Go 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"),
+    };
+}
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link OPENCODE_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 resolveOpencodeBaseUrl(settings) {
+    if (!("baseUrl" in settings))
+        return OPENCODE_BASE_URL;
+    const value = settings.baseUrl;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error("provider-opencode: settings/provider-opencode.json baseUrl must be a non-empty string when present");
+    }
+    return value.trim();
+}
+/**
+ * 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. The base URL is
+ * deployment-configurable through the scoped settings (`baseUrl` in
+ * `settings/provider-opencode.json`, constant fallback): deployments behind
+ * a proxy or mirror — and hermetic test fixtures — redirect the endpoint
+ * that way (restart-required, exactly like sigrun-pareto/sigrun-bifrost).
+ */
+export default async function sigrunOpencode(host) {
+    const settings = await host.stores.settings.get();
+    const plugin = createOpencodePlugin(resolveOpencodeBaseUrl(settings));
+    return {
+        name: "provider-opencode",
+        providers: [{ provider: plugin.provider, readiness: plugin.readiness }],
+        health: plugin.health,
+    };
+}

package/package.json

@@ -1,6 +1,51 @@
 {
-  "name": "@sigrun/provider-opencode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@sigrun/provider-opencode",
+	"version": "0.1.1",
+	"description": "Sigrun provider plugin: OpenCode's paid Go tier (OpenAI-compatible /zen/go/v1) 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-opencode && 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-opencode.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sigrun-ai/sigrun-provider-opencode/issues"
+	},
+	"homepage": "https://github.com/sigrun-ai/sigrun-provider-opencode#readme",
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "1.3.0",
+		"@earendil-works/pi-durable": "1.3.0"
+	}
+}