opencode-dux 1.0.0

package/dist/mcp/context7.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export declare const context7: RemoteMcpConfig;

package/dist/mcp/grep-app.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export declare const grep_app: RemoteMcpConfig;

package/dist/mcp/index.d.ts

@@ -0,0 +1,13 @@
+import type { WebsearchConfig } from '../config';
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones.
+ * Accepts an optional websearchConfig to override the default Exa provider.
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], websearchConfig?: WebsearchConfig): Record<string, McpConfig>;
+/**
+ * Filter MCP configs for a specific agent based on its MCP permissions.
+ * When no permission rules exist, all MCPs are available.
+ */
+export declare function filterMcpsForAgent(allMcps: Record<string, McpConfig>, _agentName: string, mcpPermissionRules?: Record<string, 'allow' | 'ask' | 'deny'>): Record<string, McpConfig>;

package/dist/mcp/types.d.ts

@@ -0,0 +1,12 @@
+export type RemoteMcpConfig = {
+    type: 'remote';
+    url: string;
+    headers?: Record<string, string>;
+    oauth?: false;
+};
+export type LocalMcpConfig = {
+    type: 'local';
+    command: string[];
+    environment?: Record<string, string>;
+};
+export type McpConfig = RemoteMcpConfig | LocalMcpConfig;

package/dist/mcp/websearch.d.ts

@@ -0,0 +1,9 @@
+import type { WebsearchConfig } from '../config';
+import type { RemoteMcpConfig } from './types';
+/**
+ * Creates a websearch MCP config based on the provided configuration.
+ * Supports Exa (default) and Tavily providers.
+ * @see https://exa.ai  @see https://tavily.com
+ */
+export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig;
+export declare const websearch: RemoteMcpConfig;

package/dist/skills/registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Metadata for a discovered skill.
+ */
+export interface SkillMetadata {
+    /** Unique skill name (derived from folder name) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Absolute path to the SKILL.md file */
+    path: string;
+    /** Tags for categorisation and matching */
+    tags: string[];
+    /** Agents that are recommended to use this skill */
+    recommendedAgents: string[];
+}
+/**
+ * Reset the skill discovery cache (for testing).
+ */
+export declare function resetSkillsCache(): void;
+/**
+ * Scan the skills directory and return parsed skill metadata.
+ * Results are cached to avoid repeated filesystem scans;
+ * call {@link resetSkillsCache} to invalidate.
+ *
+ * Files with missing or invalid frontmatter are skipped with a warning.
+ *
+ * @param pluginRoot - Absolute path to the plugin root directory.
+ */
+export declare function discoverSkills(pluginRoot: string): Promise<SkillMetadata[]>;

package/dist/subscriptions/accounts-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Local file-based storage for subscription accounts.
+ *
+ * Stores account credentials in a local JSON file alongside tui-state.json,
+ * NOT in the plugin config, so auth tokens are never committed to repos or
+ * exposed in the published schema.
+ *
+ * Supports multiple providers (OpenCode Go, Neuralwatt) via discriminated
+ * unions on the `provider` field.
+ *
+ */
+import type { StoredAccount, SubscriptionProvider } from './types';
+export type { StoredAccount };
+export type LoadAccountsResult = {
+    ok: true;
+    accounts: StoredAccount[];
+} | {
+    ok: false;
+    accounts: StoredAccount[];
+};
+declare function loadAccountsResult(): LoadAccountsResult;
+/**
+ * Load all stored accounts.
+ */
+export declare function loadAccounts(): StoredAccount[];
+export { loadAccountsResult };
+/**
+ * Load accounts filtered by provider.
+ */
+export declare function getAccountsByProvider(provider: SubscriptionProvider): StoredAccount[];
+/**
+ * Add a new account. If an account with the same name already exists,
+ * overwrites it (update).
+ */
+export declare function saveAccount(account: StoredAccount): void;
+/**
+ * Remove an account by name. Returns true if deleted, false if not found.
+ */
+export declare function removeAccount(name: string): boolean;
+/**
+ * Update the auth cookie for an existing OpenCode Go account.
+ * Returns true if updated, false if account not found or not an opencode-go account.
+ */
+export declare function updateAccountCookie(name: string, authCookie: string): boolean;
+/**
+ * Mask an auth cookie for display (show first 8 + last 4 chars).
+ */
+export declare function maskCookie(cookie: string): string;
+/**
+ * Look up a stored account by name.
+ */
+export declare function getAccount(name: string): StoredAccount | undefined;
+/**
+ * Set the provider and API key for an existing account.
+ * Returns true if updated, false if account not found.
+ */
+export declare function setAccountKey(name: string, provider: string, apiKey: string): boolean;

package/dist/subscriptions/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Multi-provider subscription tracking module.
+ *
+ * Provides account management (local storage), provider-specific scrapers,
+ * caching, and slash-command support for subscription usage data displayed
+ * in the TUI sidebar and via /subscriptions command.
+ */
+export type { StoredAccount } from './accounts-store';
+export { getAccount, getAccountsByProvider, loadAccounts, loadAccountsResult, maskCookie, removeAccount, saveAccount, setAccountKey, updateAccountCookie, } from './accounts-store';
+export { scrapeNeuralwattQuota } from './neuralwatt-scraper';
+export { scrapeQuota, scrapeUsagePage } from './opencode-go-scraper';
+export type { NeuralwattUsageEntry, OpenCodeGoUsageEntry, SubscriptionUsageEntry, UsageDetail, UsageWindow, } from './types';
+export { createUsageService, UsageService } from './usage-service';

package/dist/subscriptions/neuralwatt-scraper.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Neuralwatt quota API scraper.
+ *
+ * Fetches usage data from the Neuralwatt REST API using Bearer token
+ * authentication. Returns structured quota data including credit balance,
+ * energy usage (kWh), and subscription details.
+ *
+ * Rate limit: 1 request per second per customer.
+ */
+import type { NeuralwattUsageEntry } from './types';
+/**
+ * Fetch Neuralwatt quota data via the REST API.
+ */
+export declare function scrapeNeuralwattQuota(apiKey: string, signal?: AbortSignal): Promise<NeuralwattUsageEntry>;

package/dist/subscriptions/opencode-go-scraper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenCode Go dashboard scraper.
+ *
+ * Fetches the OpenCode Go workspace dashboard page and parses SolidJS SSR
+ * hydration output for known usage windows (rollingUsage, weeklyUsage,
+ * monthlyUsage) containing usagePercent and resetInSec fields.
+ */
+import type { OpenCodeGoUsageEntry, UsageDetail } from './types';
+interface ScrapedWindowUsage {
+    usagePercent: number;
+    resetInSec: number;
+}
+declare function parseWindowUsage(html: string, rePctFirst: RegExp, reResetFirst: RegExp): ScrapedWindowUsage | null;
+/**
+ * Fetch the OpenCode Go dashboard /go page and extract quota usage data.
+ */
+export declare function scrapeQuota(workspaceId: string, authCookie: string, signal?: AbortSignal): Promise<OpenCodeGoUsageEntry>;
+/**
+ * Scrape detailed usage data from the /usage page.
+ * The page embeds individual usage records in SolidJS SSR hydration format
+ * as $R[N]={id:"usg_...} records with model, inputTokens, outputTokens, cost fields.
+ * No total or summary is present - we aggregate from individual records.
+ */
+export declare function scrapeUsagePage(workspaceId: string, authCookie: string, signal?: AbortSignal): Promise<UsageDetail | {
+    error: string;
+}>;
+export { parseWindowUsage as _parseWindowUsage };

package/dist/subscriptions/types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Type definitions for multi-provider subscription usage tracking.
+ *
+ * Supports OpenCode Go (dashboard scraping) and Neuralwatt (REST API)
+ * as discriminated unions on the `provider` field.
+ */
+/** Provider discriminator. */
+export type SubscriptionProvider = 'opencode-go' | 'neuralwatt';
+export interface OpenCodeGoAccount {
+    provider: 'opencode-go';
+    name: string;
+    workspaceId: string;
+    authCookie: string;
+    apiKey?: string;
+}
+export interface NeuralwattAccount {
+    provider: 'neuralwatt';
+    name: string;
+    apiKey: string;
+}
+export type StoredAccount = OpenCodeGoAccount | NeuralwattAccount;
+/** Per-time-window usage data scraped from the OpenCode Go dashboard. */
+export interface UsageWindow {
+    /** Usage percentage [0..100] */
+    usagePercent: number;
+    /** Seconds until usage resets */
+    resetInSec: number;
+    /** Remaining percentage [0..100] */
+    percentRemaining: number;
+    /** ISO reset timestamp */
+    resetTimeIso: string;
+}
+/** Snapshot entry per OpenCode Go account - stored in tui-state.json. */
+export interface OpenCodeGoUsageEntry {
+    provider: 'opencode-go';
+    /** Display name for this account (from config). */
+    accountName: string;
+    /** OpenCode Go workspace ID. */
+    workspaceId: string;
+    /** Rolling (~5h) usage window, when present. */
+    rolling?: UsageWindow;
+    /** Weekly usage window, when present. */
+    weekly?: UsageWindow;
+    /** Monthly usage window, when present. */
+    monthly?: UsageWindow;
+    /** Timestamp when data was fetched. */
+    fetchedAt: number;
+    /** Error message if the scrape failed for this account. */
+    error?: string;
+}
+export interface NeuralwattBalance {
+    credits_remaining_usd: number;
+    total_credits_usd: number;
+    credits_used_usd: number;
+    accounting_method: string;
+}
+export interface NeuralwattUsagePeriod {
+    cost_usd: number;
+    requests: number;
+    tokens: number;
+    energy_kwh: number;
+}
+export interface NeuralwattUsage {
+    lifetime: NeuralwattUsagePeriod;
+    current_month: NeuralwattUsagePeriod;
+}
+export interface NeuralwattSubscription {
+    plan: string;
+    status: 'active' | 'canceling' | 'past_due' | 'paused' | 'trialing';
+    billing_interval: string | null;
+    current_period_start: string | null;
+    current_period_end: string | null;
+    auto_renew: boolean | null;
+    kwh_included: number | null;
+    kwh_used: number | null;
+    kwh_remaining: number | null;
+    in_overage: boolean | null;
+}
+/** Snapshot entry per Neuralwatt account - stored in tui-state.json. */
+export interface NeuralwattUsageEntry {
+    provider: 'neuralwatt';
+    /** Display name for this account. */
+    accountName: string;
+    /** ISO timestamp from the API response. */
+    snapshot_at: string;
+    /** Credit balance. */
+    balance: NeuralwattBalance;
+    /** Usage data (lifetime + current month). */
+    usage: NeuralwattUsage;
+    /** Subscription details, null if no active subscription. */
+    subscription: NeuralwattSubscription | null;
+    /** Timestamp when data was fetched. */
+    fetchedAt: number;
+    /** Error message if the fetch failed. */
+    error?: string;
+}
+export type SubscriptionUsageEntry = OpenCodeGoUsageEntry | NeuralwattUsageEntry;
+/** Detailed usage data from the /usage page. */
+export interface UsageDetail {
+    /** Total number of API calls. */
+    totalCalls: number;
+    /** Total estimated cost in USD. */
+    totalCost: number;
+    /** Per-model breakdown. */
+    perModel: Array<{
+        model: string;
+        calls: number;
+        cost: number;
+    }>;
+}
+/** Config for the subscription tracking feature. */
+export interface SubscriptionsConfig {
+    /** Minimum interval between auto-refreshes in ms (default: 60000). */
+    refreshIntervalMs: number;
+}

package/dist/subscriptions/usage-service.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Usage service for multi-provider subscription tracking.
+ *
+ * Manages account storage, refresh lifecycle, rate limiting, and the
+ * /subscriptions slash command.
+ *
+ * Accounts are stored locally (not in plugin config) to keep auth tokens
+ * out of version control and the published schema.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SubscriptionProvider, SubscriptionUsageEntry } from './types';
+export declare class UsageService {
+    private client;
+    private lastRefresh;
+    private pendingRefresh;
+    private cached;
+    private refreshIntervalMs;
+    private periodicTimer;
+    private periodicIntervalMs;
+    constructor(client: PluginInput['client'], refreshIntervalMs?: number, periodicIntervalMs?: number);
+    /** Get accounts from local storage. */
+    private getAccounts;
+    private getAccountsResult;
+    /**
+     * Refresh all accounts' usage data, respecting rate limit unless forced.
+     * Returns the scraped results.
+     */
+    refresh(force?: boolean): Promise<SubscriptionUsageEntry[]>;
+    private _doRefresh;
+    /**
+     * Called when orchestrator goes idle - triggers a non-forced refresh.
+     */
+    onOrchestratorIdle(): void;
+    /**
+     * Sync the active account by comparing stored API keys against
+     * auth.json. If a stored account's apiKey matches the opencode-go
+     * key in auth.json, that account is marked active. Otherwise active
+     * is cleared. This keeps the sidebar accurate even if auth.json
+     * was edited externally.
+     */
+    syncActiveAccounts(): Partial<Record<SubscriptionProvider, string>>;
+    /**
+     * Start the periodic background refresh timer.
+     */
+    private startPeriodicRefresh;
+    /**
+     * Reset the periodic timer - called after any actual refresh to
+     * restart the countdown.
+     */
+    private resetPeriodicTimer;
+    /**
+     * Clean up the periodic timer. Call when the plugin is shutting down.
+     */
+    dispose(): void;
+    /**
+     * Handle slash command: /subscriptions.
+     */
+    handleCommandExecuteBefore(input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }): Promise<void>;
+    private handleSubscriptionsCommand;
+    /**
+     * Register /subscriptions command in OpenCode config.
+     */
+    registerCommand(opencodeConfig: Record<string, unknown>): void;
+}
+export declare function createUsageService(client: PluginInput['client'], refreshIntervalMs?: number, periodicIntervalMs?: number): UsageService;

package/dist/tools/ast-grep/cli.d.ts

@@ -0,0 +1,15 @@
+import type { CliLanguage, SgResult } from './types';
+export interface RunOptions {
+    pattern: string;
+    lang: CliLanguage;
+    paths?: string[];
+    globs?: string[];
+    rewrite?: string;
+    context?: number;
+    updateAll?: boolean;
+}
+export declare function getAstGrepPath(): Promise<string | null>;
+export declare function startBackgroundInit(): void;
+export declare function runSg(options: RunOptions): Promise<SgResult>;
+export declare function isCliAvailable(): boolean;
+export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/tools/ast-grep/constants.d.ts

@@ -0,0 +1,25 @@
+import { CLI_LANGUAGES } from './types';
+export declare function findSgCliPathSync(): string | null;
+export declare function getSgCliPath(): string;
+export declare function setSgCliPath(path: string): void;
+export { CLI_LANGUAGES };
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_MATCHES = 500;
+export declare const LANG_EXTENSIONS: Record<string, string[]>;
+export interface EnvironmentCheckResult {
+    cli: {
+        available: boolean;
+        path: string;
+        error?: string;
+    };
+}
+/**
+ * Check if ast-grep CLI is available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export declare function checkEnvironment(): EnvironmentCheckResult;
+/**
+ * Format environment check result as user-friendly message.
+ */
+export declare function formatEnvironmentCheck(result: EnvironmentCheckResult): string;

package/dist/tools/ast-grep/downloader.d.ts

@@ -0,0 +1,5 @@
+export declare function getCacheDir(): string;
+export declare function getBinaryName(): string;
+export declare function getCachedBinaryPath(): string | null;
+export declare function downloadAstGrep(version?: string): Promise<string | null>;
+export declare function ensureAstGrepBinary(): Promise<string | null>;

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import { ast_grep_replace, ast_grep_search } from './tools';
+export declare const builtinTools: Record<string, ToolDefinition>;
+export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
+export type { EnvironmentCheckResult } from './constants';
+export { checkEnvironment, formatEnvironmentCheck } from './constants';
+export { ensureAstGrepBinary, getCacheDir, getCachedBinaryPath, } from './downloader';
+export type { CliLanguage, CliMatch, SgResult } from './types';
+export { CLI_LANGUAGES } from './types';
+export { ast_grep_replace, ast_grep_search };

package/dist/tools/ast-grep/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const ast_grep_search: ToolDefinition;
+export declare const ast_grep_replace: ToolDefinition;

package/dist/tools/ast-grep/types.d.ts

@@ -0,0 +1,30 @@
+export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+export interface CliMatch {
+    file: string;
+    range: {
+        byteOffset: {
+            start: number;
+            end: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    lines: string;
+    text: string;
+    replacement?: string;
+    language: string;
+}
+export interface SgResult {
+    matches: CliMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    truncatedReason?: 'timeout' | 'max_output_bytes' | 'max_matches';
+    error?: string;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CliLanguage, SgResult } from './types';
+export declare function formatSearchResult(result: SgResult): string;
+export declare function formatReplaceResult(result: SgResult, isDryRun: boolean): string;
+export declare function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null;

package/dist/tools/delegate.d.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+import type { SubagentDepthTracker } from '../utils/subagent-depth';
+/**
+ * When true, blocking `delegate_subagent` keeps the child session open and
+ * appends `<delegate_session_continue .../>` for `continue_session_id` flows.
+ */
+export declare function subagentOutputRequestsUserHandoff(text: string): boolean;
+type OpencodeClient = import('@opencode-ai/plugin').PluginInput['client'];
+export declare function createDelegateTools(ctx: {
+    client: OpencodeClient;
+    directory: string;
+}, config: PluginConfig | undefined, depthTracker: SubagentDepthTracker | undefined): Record<string, ToolDefinition>;
+export {};

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { createDelegateTools, subagentOutputRequestsUserHandoff, } from './delegate';
+export type { PresetManager } from './preset-manager';
+export { createPresetManager } from './preset-manager';
+export { createWebfetchTool } from './smartfetch';

package/dist/tools/preset-manager.d.ts

@@ -0,0 +1,27 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+/**
+ * Creates a preset manager for the /preset slash command.
+ *
+ * Uses the OpenCode SDK's client.config.update() to change agent models
+ * and temperatures without restarting. The server invalidates its agent
+ * cache and re-reads config on the next prompt.
+ *
+ * Note: activePreset is tracked in-memory only and resets on plugin reload.
+ * If the user manually edits config or another mechanism changes agents,
+ * this tracker may become stale until the next /preset call.
+ */
+export declare function createPresetManager(ctx: PluginInput, config: PluginConfig): {
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    registerCommand: (opencodeConfig: Record<string, unknown>) => void;
+};
+export type PresetManager = ReturnType<typeof createPresetManager>;

package/dist/tools/smartfetch/binary.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryFetch } from './types';
+export declare function buildBinaryResultMessage(fetchResult: BinaryFetch, savedPath?: string): string;
+export declare function saveBinary(binaryDir: string, data: Uint8Array, contentType: string, filename?: string): Promise<string>;

package/dist/tools/smartfetch/cache.d.ts

@@ -0,0 +1,6 @@
+import { LRUCache } from 'lru-cache';
+import type { FetchResult } from './types';
+export declare const CACHE: LRUCache<string, FetchResult, unknown>;
+export declare function buildCacheKey(url: string, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): string;
+export declare function cacheFetchResult(fetchResult: FetchResult, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): void;
+export declare function isInvalidLlmsResult(fetchResult: FetchResult | undefined): boolean;

package/dist/tools/smartfetch/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const DOCS_HOST_SUFFIXES: string[];
+export declare const DOCS_HOST_PREFIXES: string[];
+export declare const MAX_REDIRECTS = 10;
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_BINARY_DOWNLOAD_BYTES: number;
+export declare const DEFAULT_TIMEOUT_SECONDS = 30;
+export declare const MAX_TIMEOUT_SECONDS = 120;
+export declare const MAX_LLMS_PROBE_TIMEOUT_MS = 8000;
+export declare const MAX_MODEL_CONTENT_CHARS = 100000;
+export declare const DEFAULT_ACCEPT_LANGUAGE = "en;q=0.8,*;q=0.5";
+export declare const BINARY_PREFIXES: string[];
+export declare const WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";

package/dist/tools/smartfetch/index.d.ts

@@ -0,0 +1,3 @@
+export { WEBFETCH_DESCRIPTION } from './constants';
+export { createWebfetchTool } from './tool';
+export type { BinaryFetch, CachedFetch, FetchResult, SmartfetchOptions, } from './types';

package/dist/tools/smartfetch/network.d.ts

@@ -0,0 +1,38 @@
+import type { BinaryFetch, DecodedBody, FetchResult, FetchWithRedirectsResult, LlmsProbeResult } from './types';
+export declare function normalizeUrl(input: string): {
+    url: string;
+    upgradedToHttps: boolean;
+    fallbackUrl: string | undefined;
+    originalUrl: string;
+};
+export declare function isDocsLikeUrl(url: URL): boolean;
+export declare function buildPermissionPatterns(normalized: ReturnType<typeof normalizeUrl>, shouldProbeLlmsTxt: boolean): string[];
+export declare function buildAllowedOrigins(patterns: string[]): Set<string>;
+export declare function canUseCanonicalCacheAlias(baseUrl: string, aliasUrl: string): boolean;
+export declare function isBinaryContentType(contentType: string): boolean;
+export declare function getBinaryKind(contentType: string): BinaryFetch['binaryKind'];
+export declare function looksLikeHtmlText(text: string): boolean;
+export declare function runWithScopedTimeout<T>(parentSignal: AbortSignal, timeoutMs: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export declare function readBodyLimited(response: Response, maxBytes?: number): Promise<{
+    data: Uint8Array<ArrayBuffer>;
+    truncated: boolean;
+}>;
+export declare function fetchWithRedirects(url: string, _timeoutMs: number, format: 'text' | 'markdown' | 'html', signal: AbortSignal, extraHeaders?: Record<string, string>, method?: 'GET' | 'HEAD', allowedOrigins?: Set<string>): Promise<FetchWithRedirectsResult>;
+export declare function fetchWithUpgradeFallback(normalized: ReturnType<typeof normalizeUrl>, timeoutMs: number, format: 'text' | 'markdown' | 'html', signal: AbortSignal, extraHeaders?: Record<string, string>, method?: 'GET' | 'HEAD', allowedOrigins?: Set<string>): Promise<{
+    result: FetchWithRedirectsResult;
+    upgradedToHttps: boolean;
+}>;
+export declare function isHtmlLikeContentType(contentType: string): boolean;
+export declare function decodeBody(data: Uint8Array, charset: string | undefined, contentType?: string): DecodedBody;
+export declare function looksLikeTextBody(data: Uint8Array): boolean;
+export declare function isGenericBinaryMime(contentType: string): boolean;
+export declare function extractHeaderMetadata(headers: Headers, finalUrl: string): {
+    contentType: string | undefined;
+    charset: string | undefined;
+    etag: string | undefined;
+    lastModified: string | undefined;
+    contentLength: number | undefined;
+    filename: string | undefined;
+};
+export declare function buildConditionalHeaders(cached: FetchResult | undefined): Record<string, string> | undefined;
+export declare function probeLlmsText(url: URL, timeoutMs: number, signal: AbortSignal, fallbackOrigin?: string): Promise<LlmsProbeResult>;

package/dist/tools/smartfetch/secondary-model.d.ts

@@ -0,0 +1,28 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CachedFetch, SecondaryModel } from './types';
+type OpenCodeClient = PluginInput['client'];
+export declare function readSecondaryModelFromConfig(directory: string): Promise<SecondaryModel[]>;
+export declare function decideSecondaryModelUse(fetchResult: CachedFetch, prompt: string | undefined, secondaryModels: SecondaryModel[]): {
+    use: boolean;
+    reason: "no_prompt";
+} | {
+    use: boolean;
+    reason: "no_secondary_model_configured";
+} | {
+    use: boolean;
+    reason: "empty_content";
+} | {
+    use: boolean;
+    reason: "content_too_short";
+} | {
+    use: boolean;
+    reason: "prompt_present";
+};
+export declare function runSecondaryModelWithFallback(client: OpenCodeClient, directory: string, models: SecondaryModel[], prompt: string, content: string): Promise<{
+    model: SecondaryModel;
+    text: string;
+    inputTruncated: boolean;
+    inputChars: number;
+    sourceChars: number;
+}>;
+export {};

package/dist/tools/smartfetch/tool.d.ts

@@ -0,0 +1,3 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { SmartfetchOptions } from './types';
+export declare function createWebfetchTool(pluginCtx: PluginInput, options?: SmartfetchOptions): ToolDefinition;