@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/plugins/manager.js

@@ -0,0 +1,338 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { discoverPlugins, getPluginDirectories, loadPlugin, unloadPlugin, } from './loader.js';
+import { PluginTrustStore, } from '../runtime/plugins/trust.js';
+import { PluginQuarantineEngine } from '../runtime/plugins/quarantine.js';
+import { isHighRiskCapability, resolveCapabilityManifest } from '../runtime/plugins/manifest.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const DEFAULT_STATE = { enabled: {}, config: {}, trust: {}, quarantine: {} };
+/**
+ * PluginManager — orchestrates plugin discovery, loading, and persistence.
+ */
+export class PluginManager {
+    plugins = new Map();
+    state = { ...DEFAULT_STATE, enabled: {}, config: {}, trust: {}, quarantine: {} };
+    deps;
+    /** Trust store — manages tier records for all plugins. */
+    trustStore = new PluginTrustStore();
+    /** Quarantine engine — manages plugin quarantine state. */
+    quarantineEngine = new PluginQuarantineEngine();
+    subscribers = new Set();
+    pathOptions;
+    stateFilePath;
+    constructor(options) {
+        this.pathOptions = options.pathOptions;
+        this.stateFilePath = options.stateFilePath
+            ?? join(options.pathOptions.homeDir, '.goodvibes', 'goodvibes', 'plugins.json');
+    }
+    /**
+     * init — Must be called once at startup with application dependencies.
+     * Loads state from disk, then discovers and loads all enabled plugins.
+     */
+    async init(deps) {
+        this.deps = deps;
+        this.loadState();
+        await this.loadEnabledPlugins();
+    }
+    /** Returns status for all discovered plugins (enabled or not). */
+    list() {
+        const discovered = this.discoverPlugins();
+        return discovered.map((d) => {
+            const loaded = this.plugins.get(d.manifest.name);
+            return {
+                name: d.manifest.name,
+                version: d.manifest.version,
+                description: d.manifest.description,
+                author: d.manifest.author,
+                enabled: this.isEnabled(d.manifest.name),
+                active: loaded?.active ?? false,
+                trustTier: this.trustStore.getTier(d.manifest.name),
+                quarantined: this.quarantineEngine.isQuarantined(d.manifest.name),
+            };
+        });
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+    }
+    getTrustRecord(name) {
+        return this.trustStore.getRecord(name);
+    }
+    getQuarantineRecord(name) {
+        return this.quarantineEngine.getRecord(name);
+    }
+    /**
+     * trust — Set the trust tier for a plugin.
+     *
+     * For the `trusted` tier, prefer `trustSigned()` which also validates the
+     * signature. This method is for operator-forced tier assignment.
+     */
+    trust(name, tier, note) {
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return { ok: false, error: this.notFoundError(name) };
+        }
+        // Warn if trying to manually set 'trusted' without a signed manifest.
+        if (tier === 'trusted') {
+            const manifest = discovered.manifest;
+            if (!manifest.signature) {
+                logger.warn(`[plugins] '${name}' set to 'trusted' tier without a signed manifest — ` +
+                    'consider using /plugin verify first');
+            }
+        }
+        const record = this.trustStore.setTier(name, tier, { note });
+        this.state.trust[name] = record;
+        this.saveState();
+        logger.info(`[plugins] ${name}: trust tier set to '${tier}'`);
+        this.notifySubscribers();
+        return { ok: true };
+    }
+    /**
+     * trustSigned — Elevate a plugin to `trusted` after validating its manifest signature.
+     */
+    trustSigned(name, publicKey) {
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return { ok: false, error: this.notFoundError(name) };
+        }
+        const manifest = discovered.manifest;
+        const result = this.trustStore.trustSigned(name, manifest, publicKey);
+        if (!result.ok) {
+            return { ok: false, error: result.reason };
+        }
+        this.state.trust[name] = result.record;
+        this.saveState();
+        this.notifySubscribers();
+        return { ok: true, fingerprint: result.record.signatureFingerprint };
+    }
+    /**
+     * verify — Inspect a plugin's manifest signature without changing its tier.
+     */
+    verify(name, publicKey) {
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return { ok: false, valid: false, reason: this.notFoundError(name) };
+        }
+        const manifest = discovered.manifest;
+        const result = this.trustStore.verify(manifest, publicKey);
+        return { ok: result.valid, ...result };
+    }
+    /**
+     * capabilities — Return the capability information for a plugin.
+     *
+     * Returns the full set: requested, granted (based on current trust tier),
+     * denied, and which capabilities are high-risk.
+     */
+    capabilities(name) {
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return null;
+        }
+        const manifest = discovered.manifest;
+        const requested = (manifest.capabilities ?? []);
+        const tier = this.trustStore.getTier(name);
+        const highRisk = requested.filter((c) => isHighRiskCapability(c));
+        const safe = requested.filter((c) => !isHighRiskCapability(c));
+        // Capabilities blocked by current trust tier
+        const blocked = tier !== 'trusted' ? highRisk : [];
+        return { ok: true, requested, highRisk, safe, tier, blocked };
+    }
+    /**
+     * quarantine — Apply quarantine to a plugin.
+     *
+     * This is the high-level operator path. It resolves the plugin's declared
+     * capability manifest using the current trust tier, then applies quarantine
+     * immediately to the resolved capability set.
+     */
+    quarantine(name, reason) {
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return { ok: false, error: this.notFoundError(name) };
+        }
+        if (this.quarantineEngine.isQuarantined(name)) {
+            return { ok: false, error: `Plugin '${name}' is already quarantined` };
+        }
+        const trustTier = this.trustStore.getTier(name);
+        const capabilityManifest = resolveCapabilityManifest(name, discovered.manifest, undefined, trustTier);
+        const record = this.quarantineEngine.quarantine(name, capabilityManifest, reason);
+        if (!record) {
+            return { ok: false, error: `Failed to quarantine '${name}'` };
+        }
+        this.state.quarantine[name] = { ...record, revokedCapabilities: [...record.revokedCapabilities] };
+        this.saveState();
+        logger.warn(`[plugins] ${name}: quarantined — ${reason}`);
+        this.notifySubscribers();
+        return { ok: true };
+    }
+    /**
+     * liftQuarantine — Remove quarantine from a plugin.
+     */
+    liftQuarantine(name) {
+        if (!this.quarantineEngine.isQuarantined(name)) {
+            return { ok: false, error: `Plugin '${name}' is not quarantined` };
+        }
+        this.quarantineEngine.lift(name);
+        const record = this.quarantineEngine.getRecord(name);
+        if (record) {
+            this.state.quarantine[name] = { ...record, revokedCapabilities: [...record.revokedCapabilities] };
+        }
+        this.saveState();
+        logger.info(`[plugins] ${name}: quarantine lifted`);
+        this.notifySubscribers();
+        return { ok: true };
+    }
+    /** Enable a plugin by name. Loads it immediately if deps are available. */
+    async enable(name) {
+        if (this.isEnabled(name)) {
+            return { ok: false, error: `Plugin '${name}' is already enabled` };
+        }
+        const discovered = this.findDiscoveredPlugin(name);
+        if (!discovered) {
+            return { ok: false, error: this.notFoundError(name) };
+        }
+        this.state.enabled[name] = true;
+        this.saveState();
+        if (this.deps) {
+            const loaded = await loadPlugin(discovered, this.deps);
+            if (loaded) {
+                this.plugins.set(name, loaded);
+                this.notifySubscribers();
+            }
+            else {
+                // Revert enable on load failure
+                delete this.state.enabled[name];
+                this.saveState();
+                return { ok: false, error: `Plugin '${name}' failed to load — check logs` };
+            }
+        }
+        return { ok: true };
+    }
+    /** Disable a plugin by name. Deactivates it immediately if active. */
+    async disable(name) {
+        if (!this.isEnabled(name)) {
+            return { ok: false, error: `Plugin '${name}' is not enabled` };
+        }
+        const loaded = this.plugins.get(name);
+        if (loaded) {
+            await unloadPlugin(loaded);
+            this.plugins.delete(name);
+        }
+        delete this.state.enabled[name];
+        this.saveState();
+        this.notifySubscribers();
+        return { ok: true };
+    }
+    /** Reload all currently enabled plugins (deactivate then reactivate). */
+    async reload() {
+        const names = Object.keys(this.state.enabled).filter((n) => this.state.enabled[n]);
+        let reloaded = 0;
+        let failed = 0;
+        // Deactivate all
+        for (const name of names) {
+            const loaded = this.plugins.get(name);
+            if (loaded) {
+                await unloadPlugin(loaded);
+                this.plugins.delete(name);
+            }
+        }
+        // Reactivate with cache busting — append timestamp to force fresh import
+        if (this.deps) {
+            const discovered = this.discoverPlugins();
+            const cacheBust = Date.now();
+            for (const d of discovered) {
+                if (!this.isEnabled(d.manifest.name))
+                    continue;
+                // Pass cacheBust so loadPlugin appends ?t=<timestamp> to the import URL,
+                // forcing Bun to bypass its module cache and re-execute the file.
+                const loaded = await loadPlugin(d, this.deps, cacheBust);
+                if (loaded) {
+                    this.plugins.set(d.manifest.name, loaded);
+                    reloaded++;
+                }
+                else {
+                    failed++;
+                }
+            }
+        }
+        this.notifySubscribers();
+        return { reloaded, failed };
+    }
+    /** Returns whether a plugin is marked as enabled in persisted state. */
+    isEnabled(name) {
+        return this.state.enabled[name] === true;
+    }
+    /** Returns plugin-specific config for a given plugin name. */
+    getPluginConfig(name) {
+        return this.state.config[name] ?? {};
+    }
+    // ─── Private helpers ────────────────────────────────────────────────────────
+    async loadEnabledPlugins() {
+        if (!this.deps)
+            return;
+        const discovered = this.discoverPlugins();
+        for (const d of discovered) {
+            if (!this.isEnabled(d.manifest.name))
+                continue;
+            const loaded = await loadPlugin(d, this.deps);
+            if (loaded) {
+                this.plugins.set(d.manifest.name, loaded);
+            }
+        }
+        this.notifySubscribers();
+    }
+    loadState() {
+        try {
+            if (existsSync(this.stateFilePath)) {
+                const raw = readFileSync(this.stateFilePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                this.state.enabled = parsed.enabled ?? {};
+                this.state.config = parsed.config ?? {};
+                this.state.trust = parsed.trust ?? {};
+                this.state.quarantine = parsed.quarantine ?? {};
+                // Restore trust and quarantine state into their engines.
+                if (Object.keys(this.state.trust).length > 0) {
+                    this.trustStore.importRecords(this.state.trust);
+                }
+                // Note: quarantine records are read-only from persistence; active
+                // quarantines take effect when plugins are loaded via PluginLifecycleManager.
+            }
+        }
+        catch (err) {
+            logger.warn(`[plugins] Could not load state: ${summarizeError(err)}`);
+        }
+    }
+    saveState() {
+        try {
+            mkdirSync(dirname(this.stateFilePath), { recursive: true });
+            writeFileSync(this.stateFilePath, JSON.stringify(this.state, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`[plugins] Could not save state: ${summarizeError(err)}`);
+        }
+    }
+    discoverPlugins() {
+        return discoverPlugins(this.pathOptions);
+    }
+    findDiscoveredPlugin(name) {
+        return this.discoverPlugins().find((plugin) => plugin.manifest.name === name);
+    }
+    notFoundError(name) {
+        return `Plugin '${name}' not found in configured plugin search directories (${this.describeSearchDirectories()})`;
+    }
+    describeSearchDirectories() {
+        return getPluginDirectories(this.pathOptions).join(', ');
+    }
+    notifySubscribers() {
+        for (const callback of this.subscribers) {
+            try {
+                callback();
+            }
+            catch (err) {
+                logger.debug('[plugins] subscriber callback failed', {
+                    error: summarizeError(err),
+                });
+            }
+        }
+    }
+}

package/dist/_internal/platform/profiles/manager.d.ts

@@ -19,7 +19,7 @@ export interface ProfileInfo {
 /**
  * ProfileManager - Save and load named SDK host config profiles.
  *
- * Profiles are stored as JSON files in ~/.goodvibes/tui/profiles/<name>.json.
+ * Profiles are stored as JSON files in ~/.goodvibes/goodvibes/profiles/<name>.json.
  * Only host-surface settings (display, provider, behavior categories) are saved;
  * permissions and API keys are never included.
  */

package/dist/_internal/platform/profiles/manager.js

@@ -5,7 +5,7 @@ import { summarizeError } from '../utils/error-display.js';
 /**
  * ProfileManager - Save and load named SDK host config profiles.
  *
- * Profiles are stored as JSON files in ~/.goodvibes/tui/profiles/<name>.json.
+ * Profiles are stored as JSON files in ~/.goodvibes/goodvibes/profiles/<name>.json.
  * Only host-surface settings (display, provider, behavior categories) are saved;
  * permissions and API keys are never included.
  */

package/dist/_internal/platform/profiles/shape.d.ts

@@ -0,0 +1,5 @@
+import { type ConfigKey } from '../config/index.js';
+import type { ProfileData } from '@pellux/goodvibes-sdk/platform/profiles/manager';
+export declare function configSnapshotToProfileData(snapshot: Record<string, unknown>): ProfileData;
+export declare function profileDataToConfigSnapshot(data: ProfileData): Partial<Record<ConfigKey, unknown>>;
+//# sourceMappingURL=shape.d.ts.map

package/dist/_internal/platform/profiles/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/profiles/shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AAwBnF,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW,CAgB1F;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAclG"}

package/dist/_internal/platform/profiles/shape.js

@@ -0,0 +1,51 @@
+import { CONFIG_SCHEMA } from '../config/index.js';
+function setNestedValue(target, path, value) {
+    let current = target;
+    for (let index = 0; index < path.length - 1; index += 1) {
+        const segment = path[index];
+        const existing = current[segment];
+        if (!existing || typeof existing !== 'object') {
+            current[segment] = {};
+        }
+        current = current[segment];
+    }
+    current[path[path.length - 1]] = structuredClone(value);
+}
+function getNestedValue(source, path) {
+    let current = source;
+    for (const segment of path) {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+export function configSnapshotToProfileData(snapshot) {
+    const profile = {};
+    for (const entry of CONFIG_SCHEMA) {
+        if (!entry.key.startsWith('display.')
+            && !entry.key.startsWith('provider.')
+            && !entry.key.startsWith('behavior.')) {
+            continue;
+        }
+        const value = snapshot[entry.key];
+        if (value !== undefined) {
+            setNestedValue(profile, entry.key.split('.'), value);
+        }
+    }
+    return profile;
+}
+export function profileDataToConfigSnapshot(data) {
+    const snapshot = {};
+    for (const entry of CONFIG_SCHEMA) {
+        if (!entry.key.startsWith('display.')
+            && !entry.key.startsWith('provider.')
+            && !entry.key.startsWith('behavior.')) {
+            continue;
+        }
+        const value = getNestedValue(data, entry.key.split('.'));
+        if (value !== undefined)
+            snapshot[entry.key] = structuredClone(value);
+    }
+    return snapshot;
+}

package/dist/_internal/platform/providers/amazon-bedrock-mantle.d.ts

@@ -0,0 +1,5 @@
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+export declare class AmazonBedrockMantleProvider extends AnthropicSdkProvider {
+    constructor();
+}
+//# sourceMappingURL=amazon-bedrock-mantle.d.ts.map

package/dist/_internal/platform/providers/amazon-bedrock-mantle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amazon-bedrock-mantle.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/amazon-bedrock-mantle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgBnE,qBAAa,2BAA4B,SAAQ,oBAAoB;;CAgCpE"}

package/dist/_internal/platform/providers/amazon-bedrock-mantle.js

@@ -0,0 +1,45 @@
+import { AnthropicBedrockMantle } from '@anthropic-ai/bedrock-sdk';
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+const BEDROCK_MANTLE_MODELS = [
+    'claude-sonnet-4-6',
+    'claude-opus-4-6',
+    'claude-haiku-4-5',
+];
+function hasMantleCredentials() {
+    return Boolean(process.env['AWS_BEARER_TOKEN_BEDROCK']
+        || (process.env['AWS_ACCESS_KEY_ID'] && process.env['AWS_SECRET_ACCESS_KEY'])
+        || process.env['AWS_PROFILE']);
+}
+export class AmazonBedrockMantleProvider extends AnthropicSdkProvider {
+    constructor() {
+        const configured = hasMantleCredentials();
+        super({
+            name: 'amazon-bedrock-mantle',
+            label: 'Amazon Bedrock Mantle',
+            defaultModel: 'claude-sonnet-4-6',
+            models: BEDROCK_MANTLE_MODELS,
+            createClient: () => new AnthropicBedrockMantle({
+                apiKey: process.env['AWS_BEARER_TOKEN_BEDROCK'],
+                awsAccessKey: process.env['AWS_ACCESS_KEY_ID'] ?? null,
+                awsSecretAccessKey: process.env['AWS_SECRET_ACCESS_KEY'] ?? null,
+                awsSessionToken: process.env['AWS_SESSION_TOKEN'] ?? null,
+                awsProfile: process.env['AWS_PROFILE'],
+                awsRegion: process.env['AWS_REGION'] ?? process.env['AWS_DEFAULT_REGION'] ?? 'us-east-1',
+            }),
+            auth: {
+                mode: configured ? 'api-key' : 'anonymous',
+                configured,
+                detail: configured
+                    ? 'Bedrock Mantle auth is available through bearer token or AWS credential resolution.'
+                    : 'Configure AWS_BEARER_TOKEN_BEDROCK or AWS credentials/profile for Bedrock Mantle.',
+                envVars: ['AWS_BEARER_TOKEN_BEDROCK', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN', 'AWS_PROFILE', 'AWS_REGION'],
+                secretKeys: ['AWS_BEARER_TOKEN_BEDROCK'],
+                allowAnonymous: true,
+                anonymousConfigured: Boolean(process.env['AWS_PROFILE']),
+                anonymousDetail: 'Bedrock Mantle can also use the AWS credential provider chain.',
+            },
+            streamProtocol: 'anthropic-sdk-stream',
+            notes: ['Bedrock Mantle uses the Anthropic Bedrock Mantle SDK path.'],
+        });
+    }
+}

package/dist/_internal/platform/providers/amazon-bedrock.d.ts

@@ -0,0 +1,5 @@
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+export declare class AmazonBedrockProvider extends AnthropicSdkProvider {
+    constructor();
+}
+//# sourceMappingURL=amazon-bedrock.d.ts.map

package/dist/_internal/platform/providers/amazon-bedrock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amazon-bedrock.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/amazon-bedrock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgBnE,qBAAa,qBAAsB,SAAQ,oBAAoB;;CA2C9D"}

package/dist/_internal/platform/providers/amazon-bedrock.js

@@ -0,0 +1,56 @@
+import { AnthropicBedrock } from '@anthropic-ai/bedrock-sdk';
+import { AnthropicSdkProvider } from './anthropic-sdk-provider.js';
+const BEDROCK_MODELS = [
+    'claude-opus-4-6',
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5',
+];
+function hasAwsCredentials() {
+    return Boolean(process.env['AWS_BEARER_TOKEN_BEDROCK']
+        || (process.env['AWS_ACCESS_KEY_ID'] && process.env['AWS_SECRET_ACCESS_KEY'])
+        || process.env['AWS_PROFILE']);
+}
+export class AmazonBedrockProvider extends AnthropicSdkProvider {
+    constructor() {
+        const configured = hasAwsCredentials();
+        super({
+            name: 'amazon-bedrock',
+            label: 'Amazon Bedrock',
+            defaultModel: 'claude-sonnet-4-6',
+            models: BEDROCK_MODELS,
+            createClient: () => {
+                const apiKey = process.env['AWS_BEARER_TOKEN_BEDROCK']?.trim();
+                const awsAccessKey = process.env['AWS_ACCESS_KEY_ID']?.trim();
+                const awsSecretKey = process.env['AWS_SECRET_ACCESS_KEY']?.trim();
+                const awsSessionToken = process.env['AWS_SESSION_TOKEN']?.trim();
+                const baseOptions = {
+                    ...(apiKey ? { apiKey } : {}),
+                    awsRegion: process.env['AWS_REGION'] ?? process.env['AWS_DEFAULT_REGION'] ?? 'us-east-1',
+                };
+                if (awsAccessKey && awsSecretKey) {
+                    return new AnthropicBedrock({
+                        ...baseOptions,
+                        awsAccessKey,
+                        awsSecretKey,
+                        ...(awsSessionToken ? { awsSessionToken } : {}),
+                    });
+                }
+                return new AnthropicBedrock(baseOptions);
+            },
+            auth: {
+                mode: configured ? 'api-key' : 'anonymous',
+                configured,
+                detail: configured
+                    ? 'AWS Bedrock credentials are available through bearer token or AWS credential resolution.'
+                    : 'Configure AWS_BEARER_TOKEN_BEDROCK or AWS credentials/profile for Amazon Bedrock.',
+                envVars: ['AWS_BEARER_TOKEN_BEDROCK', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN', 'AWS_PROFILE', 'AWS_REGION'],
+                secretKeys: ['AWS_BEARER_TOKEN_BEDROCK'],
+                allowAnonymous: true,
+                anonymousConfigured: Boolean(process.env['AWS_PROFILE']),
+                anonymousDetail: 'The AWS credential provider chain can satisfy Bedrock auth without storing an API key in GoodVibes.',
+            },
+            streamProtocol: 'anthropic-sdk-stream',
+            notes: ['Claude-on-Bedrock models are exposed through the Anthropic Bedrock SDK.'],
+        });
+    }
+}

package/dist/_internal/platform/providers/anthropic-compat.d.ts

@@ -0,0 +1,61 @@
+import type { LLMProvider, ChatRequest, ChatResponse, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+export interface AnthropicCompatOptions {
+    /** Unique provider identifier, e.g. 'my-anthropic-proxy' */
+    name: string;
+    /** Base URL for the Anthropic Messages API, e.g. 'https://my-proxy.example.com/v1' */
+    baseURL: string;
+    /** API key sent as the x-api-key header */
+    apiKey: string;
+    /** Model ID to use when none is specified in ChatRequest */
+    defaultModel: string;
+    /** List of model IDs exposed by this provider */
+    models: string[];
+    /** Optional extra HTTP headers sent with every request */
+    defaultHeaders?: Record<string, string>;
+    /** Optional env vars or secret keys that can satisfy auth for this provider. */
+    authEnvVars?: readonly string[];
+    /** Optional service names that expose service-owned OAuth for this provider. */
+    serviceNames?: readonly string[];
+    /** Optional provider aliases exposed to runtime metadata consumers. */
+    aliases?: readonly string[];
+    /** Optional subscription-provider identity when this provider can use a stored OAuth session. */
+    subscriptionProviderId?: string;
+    /** Optional explicit stream protocol label for diagnostics. */
+    streamProtocol?: string;
+    /** Optional auth header mode. Default: x-api-key. */
+    authHeaderMode?: 'x-api-key' | 'bearer';
+    /** Optional anonymous/local access posture. */
+    allowAnonymous?: boolean;
+    anonymousConfigured?: boolean;
+    anonymousDetail?: string;
+}
+/**
+ * AnthropicCompatProvider — generic provider for endpoints that speak the
+ * Anthropic Messages API (SSE streaming variant). Useful for self-hosted
+ * proxies, Claude-compatible services, and any backend that mirrors the
+ * Anthropic Messages API spec.
+ *
+ * Configured via a custom provider JSON file with `"type": "anthropic-compat"`
+ * in ~/.goodvibes/goodvibes/providers/.
+ */
+export declare class AnthropicCompatProvider implements LLMProvider {
+    readonly name: string;
+    readonly models: string[];
+    private baseURL;
+    private apiKey;
+    private defaultModel;
+    private defaultHeaders;
+    private readonly authEnvVars;
+    private readonly serviceNames;
+    private readonly aliases;
+    private readonly subscriptionProviderId?;
+    private readonly streamProtocol?;
+    private readonly authHeaderMode;
+    private readonly allowAnonymous;
+    private readonly anonymousConfigured;
+    private readonly anonymousDetail?;
+    constructor(opts: AnthropicCompatOptions);
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+//# sourceMappingURL=anthropic-compat.d.ts.map

package/dist/_internal/platform/providers/anthropic-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-compat.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/anthropic-compat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AA6CxB,MAAM,WAAW,sBAAsB;IACrC,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,gFAAgF;IAChF,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,gFAAgF;IAChF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,uEAAuE;IACvE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,iGAAiG;IACjG,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,cAAc,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC;IACxC,+CAA+C;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,qBAAa,uBAAwB,YAAW,WAAW;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAE1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyB;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAU;IAC9C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAS;gBAE9B,IAAI,EAAE,sBAAsB;IAkBlC,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAwMhD,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CA6C3F"}