thoth-agents 0.1.0

package/dist/mcp/context7.d.ts

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

package/dist/mcp/exa.d.ts

@@ -0,0 +1,6 @@
+import type { LocalMcpConfig } from './types';
+/**
+ * Exa AI web search - real-time web search
+ * @see https://exa.ai/docs/reference/exa-mcp
+ */
+export declare const exa: LocalMcpConfig;

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

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

package/dist/mcp/index.d.ts

@@ -0,0 +1,7 @@
+import type { ThothConfig } from '../config';
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], thothConfig?: ThothConfig): Record<string, McpConfig>;

package/dist/mcp/thoth.d.ts

@@ -0,0 +1,3 @@
+import { type ThothConfig } from '../config';
+import type { LocalMcpConfig } from './types';
+export declare function createThothMcp(config?: ThothConfig): LocalMcpConfig;

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/sdd/artifact-governance/artifact-loader.d.ts

@@ -0,0 +1,55 @@
+import { type ArtifactGovernanceMode, type ArtifactGovernanceResult } from './types';
+type MaybePromise<T> = T | Promise<T>;
+export type ArtifactSnapshotSource = 'prompt' | 'thoth-mem' | 'openspec';
+export interface ArtifactSnapshotInput {
+    content: string;
+    location?: string;
+    updatedAt?: string;
+    observationId?: number;
+}
+export interface ArtifactSnapshot extends ArtifactSnapshotInput {
+    source: ArtifactSnapshotSource;
+}
+export interface ArtifactLoaderRequest {
+    mode: ArtifactGovernanceMode;
+    changeName: string;
+    artifact: string;
+    promptSnapshot?: ArtifactSnapshotInput;
+    workspaceRoot?: string;
+}
+export interface ArtifactLoaderDescriptor {
+    changeName: string;
+    artifact: string;
+    topicKey: string;
+    openspecPath: string;
+}
+export interface ArtifactLoaderDependencies {
+    readThothArtifact?: (descriptor: ArtifactLoaderDescriptor) => MaybePromise<ArtifactSnapshotInput | null>;
+    readOpenspecArtifact?: (descriptor: ArtifactLoaderDescriptor) => MaybePromise<ArtifactSnapshotInput | null>;
+}
+export interface ArtifactComparisonMetadata {
+    status: 'not-applicable' | 'single-source' | 'match' | 'diverged';
+    sourceOfTruth: ArtifactSnapshotSource | null;
+    recoverable: boolean;
+    missingSources: readonly ArtifactSnapshotSource[];
+    metadata: Readonly<{
+        comparedSources: readonly ArtifactSnapshotSource[];
+        matched?: boolean;
+        thothLength?: number;
+        openspecLength?: number;
+    }>;
+}
+export interface ArtifactLoaderResult extends ArtifactGovernanceResult {
+    snapshot: ArtifactSnapshot | null;
+    descriptor: ArtifactLoaderDescriptor;
+    comparison: ArtifactComparisonMetadata;
+    sources: Readonly<{
+        prompt: ArtifactSnapshot | null;
+        thothMem: ArtifactSnapshot | null;
+        openspec: ArtifactSnapshot | null;
+    }>;
+}
+export declare function getArtifactTopicKey(changeName: string, artifact: string): string;
+export declare function getArtifactOpenSpecPath(changeName: string, artifact: string): string;
+export declare function loadArtifactSnapshot(request: ArtifactLoaderRequest, dependencies?: ArtifactLoaderDependencies): Promise<ArtifactLoaderResult>;
+export {};

package/dist/sdd/artifact-governance/index.d.ts

@@ -0,0 +1,6 @@
+export type { ArtifactComparisonMetadata, ArtifactLoaderDependencies, ArtifactLoaderDescriptor, ArtifactLoaderRequest, ArtifactLoaderResult, ArtifactSnapshot, ArtifactSnapshotInput, ArtifactSnapshotSource, } from './artifact-loader';
+export { getArtifactOpenSpecPath, getArtifactTopicKey, loadArtifactSnapshot, } from './artifact-loader';
+export type { ValidateTasksArtifactPersistence, ValidateTasksArtifactRequest, } from './tasks-validator';
+export { validateTasksArtifact } from './tasks-validator';
+export type { ArtifactGovernanceEnforcementMode, ArtifactGovernanceFinding, ArtifactGovernanceMetadataValue, ArtifactGovernanceMode, ArtifactGovernanceReport, ArtifactGovernanceResult, ArtifactGovernanceSeverity, ArtifactGovernanceSummary, CreateArtifactGovernanceReportOptions, CreateArtifactGovernanceResultOptions, } from './types';
+export { ARTIFACT_GOVERNANCE_ENFORCEMENT_MODES, ARTIFACT_GOVERNANCE_MODES, ARTIFACT_GOVERNANCE_SEVERITIES, createArtifactGovernanceReport, createArtifactGovernanceResult, getHighestArtifactGovernanceSeverity, isArtifactGovernanceSeverity, summarizeArtifactGovernanceFindings, } from './types';

package/dist/sdd/artifact-governance/tasks-validator.d.ts

@@ -0,0 +1,17 @@
+import type { ArtifactComparisonMetadata, ArtifactSnapshot } from './artifact-loader';
+import { type ArtifactGovernanceMode, type ArtifactGovernanceResult } from './types';
+export interface ValidateTasksArtifactRequest {
+    mode: ArtifactGovernanceMode;
+    content: string;
+    path?: string;
+    persistence?: ValidateTasksArtifactPersistence;
+}
+export interface ValidateTasksArtifactPersistence {
+    comparison: ArtifactComparisonMetadata;
+    sources: Readonly<{
+        prompt: ArtifactSnapshot | null;
+        thothMem: ArtifactSnapshot | null;
+        openspec: ArtifactSnapshot | null;
+    }>;
+}
+export declare function validateTasksArtifact(request: ValidateTasksArtifactRequest): ArtifactGovernanceResult;

package/dist/sdd/artifact-governance/types.d.ts

@@ -0,0 +1,52 @@
+export declare const ARTIFACT_GOVERNANCE_SEVERITIES: readonly ["error", "warning", "info"];
+export type ArtifactGovernanceSeverity = (typeof ARTIFACT_GOVERNANCE_SEVERITIES)[number];
+export declare const ARTIFACT_GOVERNANCE_MODES: readonly ["none", "thoth-mem", "openspec", "hybrid"];
+export type ArtifactGovernanceMode = (typeof ARTIFACT_GOVERNANCE_MODES)[number];
+export declare const ARTIFACT_GOVERNANCE_ENFORCEMENT_MODES: readonly ["report-only"];
+export type ArtifactGovernanceEnforcementMode = (typeof ARTIFACT_GOVERNANCE_ENFORCEMENT_MODES)[number];
+export type ArtifactGovernanceMetadataValue = string | number | boolean | null;
+export interface ArtifactGovernanceFinding {
+    code: string;
+    severity: ArtifactGovernanceSeverity;
+    message: string;
+    path?: string;
+    line?: number;
+    column?: number;
+    detail?: string;
+    source?: string;
+    metadata?: Readonly<Record<string, ArtifactGovernanceMetadataValue>>;
+}
+export interface ArtifactGovernanceSummary {
+    total: number;
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    highestSeverity: ArtifactGovernanceSeverity | null;
+}
+export interface ArtifactGovernanceReport {
+    mode: ArtifactGovernanceMode;
+    enforcementMode: ArtifactGovernanceEnforcementMode;
+    findings: readonly ArtifactGovernanceFinding[];
+    summary: ArtifactGovernanceSummary;
+    valid: boolean;
+    shouldBlock: boolean;
+}
+export interface ArtifactGovernanceResult extends ArtifactGovernanceReport {
+    validator: string;
+    artifact: string;
+    report: ArtifactGovernanceReport;
+}
+export interface CreateArtifactGovernanceReportOptions {
+    mode?: ArtifactGovernanceMode;
+    enforcementMode?: ArtifactGovernanceEnforcementMode;
+    findings?: readonly ArtifactGovernanceFinding[];
+}
+export interface CreateArtifactGovernanceResultOptions extends CreateArtifactGovernanceReportOptions {
+    validator: string;
+    artifact: string;
+}
+export declare function isArtifactGovernanceSeverity(value: string): value is ArtifactGovernanceSeverity;
+export declare function getHighestArtifactGovernanceSeverity(findings: readonly ArtifactGovernanceFinding[]): ArtifactGovernanceSeverity | null;
+export declare function summarizeArtifactGovernanceFindings(findings: readonly ArtifactGovernanceFinding[]): ArtifactGovernanceSummary;
+export declare function createArtifactGovernanceReport(options?: CreateArtifactGovernanceReportOptions): ArtifactGovernanceReport;
+export declare function createArtifactGovernanceResult(options: CreateArtifactGovernanceResultOptions): ArtifactGovernanceResult;

package/dist/thoth/client.d.ts

@@ -0,0 +1,14 @@
+export interface CreateThothClientOptions {
+    project: string;
+    directory?: string;
+    httpPort?: number;
+    timeoutMs?: number;
+    enabled?: boolean;
+}
+export interface ThothClient {
+    readonly enabled: boolean;
+    memContext(sessionId?: string, limit?: number): Promise<string | null>;
+    memSessionStart(sessionId: string): Promise<boolean>;
+    memSavePrompt(sessionId: string, content: string): Promise<boolean>;
+}
+export declare function createThothClient(options: CreateThothClientOptions): ThothClient;

package/dist/thoth/index.d.ts

@@ -0,0 +1,2 @@
+export type { CreateThothClientOptions, ThothClient } from './client';
+export { createThothClient } from './client';

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 { ast_grep_search, ast_grep_replace };
+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';

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/index.d.ts

@@ -0,0 +1,2 @@
+export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { lsp_diagnostics, lsp_find_references, lsp_goto_definition, lsp_rename, lspManager, setUserLspConfig, } from './lsp';

package/dist/tools/lsp/client.d.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic, ResolvedServer } from './types';
+declare class LSPServerManager {
+    private static instance;
+    private clients;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    private constructor();
+    private registerProcessCleanup;
+    static getInstance(): LSPServerManager;
+    private getKey;
+    private startCleanupTimer;
+    private cleanupIdleClients;
+    getClient(root: string, server: ResolvedServer): Promise<LSPClient>;
+    releaseClient(root: string, serverId: string): void;
+    isServerInitializing(root: string, serverId: string): boolean;
+    stopAll(): Promise<void>;
+}
+export declare const lspManager: LSPServerManager;
+export declare class LSPClient {
+    private root;
+    private server;
+    private proc;
+    private connection;
+    private openedFiles;
+    private stderrBuffer;
+    private processExited;
+    private diagnosticsStore;
+    constructor(root: string, server: ResolvedServer);
+    start(): Promise<void>;
+    private startStderrReading;
+    initialize(): Promise<void>;
+    openFile(filePath: string): Promise<void>;
+    definition(filePath: string, line: number, character: number): Promise<unknown>;
+    references(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown>;
+    diagnostics(filePath: string): Promise<{
+        items: Diagnostic[];
+    }>;
+    rename(filePath: string, line: number, character: number, newName: string): Promise<unknown>;
+    isAlive(): boolean;
+    stop(): Promise<void>;
+}
+export {};

package/dist/tools/lsp/config-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * User-provided LSP server config (from opencode.json lsp section).
+ * Fields are optional because user config may not include all properties.
+ */
+export interface UserLspConfig {
+    id: string;
+    command?: string[];
+    extensions?: string[];
+    disabled?: boolean;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+/**
+ * Set the user's lsp config from opencode.json.
+ * Called during plugin initialization.
+ */
+export declare function setUserLspConfig(config: Record<string, unknown> | undefined): void;
+/**
+ * Get the user's lsp config for a specific server ID.
+ */
+export declare function getUserLspConfig(serverId: string): UserLspConfig | undefined;
+/**
+ * Get all user-configured lsp servers.
+ */
+export declare function getAllUserLspConfigs(): Map<string, UserLspConfig>;
+/**
+ * Check if user has configured any lsp servers.
+ */
+export declare function hasUserLspConfig(): boolean;

package/dist/tools/lsp/config.d.ts

@@ -0,0 +1,4 @@
+import type { ServerLookupResult } from './types';
+export declare function findServerForExtension(ext: string): ServerLookupResult;
+export declare function getLanguageId(ext: string): string;
+export declare function isServerInstalled(command: string[]): boolean;

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

@@ -0,0 +1,25 @@
+import type { LSPServerConfig, RootFunction } from './types';
+export declare const SYMBOL_KIND_MAP: Record<number, string>;
+export declare const SEVERITY_MAP: Record<number, string>;
+export declare const DEFAULT_MAX_REFERENCES = 200;
+export declare const DEFAULT_MAX_DIAGNOSTICS = 200;
+export declare const LOCK_FILE_PATTERNS: string[];
+/**
+ * NearestRoot helper - mirrors OpenCode core's NearestRoot function.
+ * Creates a RootFunction that walks up directories looking for root markers.
+ */
+export declare function NearestRoot(includePatterns: string[], excludePatterns?: string[]): RootFunction;
+/**
+ * Built-in LSP servers - mirrors OpenCode core LSPServer namespace.
+ * User configuration from opencode.json lsp section takes precedence and is
+ * merged on top of these: user settings override command/extensions/env, while
+ * root patterns are always preserved from built-in. Servers can be removed by
+ * setting `"disabled": true` in the user config.
+ */
+export declare const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, 'id'>>;
+export declare const LSP_INSTALL_HINTS: Record<string, string>;
+/**
+ * Maps file extensions to LSP language IDs.
+ * Mirrors OpenCode core's LANGUAGE_EXTENSIONS constant.
+ */
+export declare const LANGUAGE_EXTENSIONS: Record<string, string>;

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

@@ -0,0 +1,4 @@
+export { lspManager } from './client';
+export { getUserLspConfig, setUserLspConfig } from './config-store';
+export { lsp_diagnostics, lsp_find_references, lsp_goto_definition, lsp_rename, } from './tools';
+export type { Diagnostic, Location, LSPServerConfig, ResolvedServer, WorkspaceEdit, } from './types';

package/dist/tools/lsp/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const lsp_goto_definition: ToolDefinition;
+export declare const lsp_find_references: ToolDefinition;
+export declare const lsp_diagnostics: ToolDefinition;
+export declare const lsp_rename: ToolDefinition;

package/dist/tools/lsp/types.d.ts

@@ -0,0 +1,35 @@
+import type { CreateFile, DeleteFile, Diagnostic, DocumentSymbol, Location, LocationLink, Position, Range, RenameFile, SymbolInformation as SymbolInfo, TextDocumentEdit, TextDocumentIdentifier, TextEdit, VersionedTextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver-protocol';
+/**
+ * Root function type - mirrors OpenCode core's RootFunction.
+ * Returns the project root directory for a given file, or undefined if not applicable.
+ */
+export type RootFunction = (file: string) => string | undefined;
+export interface LSPServerConfig {
+    id: string;
+    command: string[];
+    extensions: string[];
+    root?: RootFunction;
+    disabled?: boolean;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export interface ResolvedServer {
+    id: string;
+    command: string[];
+    extensions: string[];
+    root?: RootFunction;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export type ServerLookupResult = {
+    status: 'found';
+    server: ResolvedServer;
+} | {
+    status: 'not_configured';
+    extension: string;
+} | {
+    status: 'not_installed';
+    server: ResolvedServer;
+    installHint: string;
+};
+export type { Position, Range, Location, LocationLink, Diagnostic, TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, SymbolInfo, DocumentSymbol, };

package/dist/tools/lsp/utils.d.ts

@@ -0,0 +1,34 @@
+import type { LSPClient } from './client';
+import type { Diagnostic, Location, LocationLink, ResolvedServer, ServerLookupResult, WorkspaceEdit } from './types';
+/**
+ * Find the project root for a specific LSP server using its root function.
+ * Mirrors OpenCode core's RootFunction approach.
+ *
+ * @param filePath - The file to find the root for
+ * @param server - The LSP server config with root function
+ * @returns The project root directory, or file's directory if no root function
+ */
+export declare function findServerProjectRoot(filePath: string, server: ResolvedServer): string;
+/**
+ * Legacy function for backward compatibility.
+ * @deprecated Use findServerProjectRoot with server-specific patterns instead.
+ */
+export declare function findWorkspaceRoot(filePath: string): string;
+export declare function uriToPath(uri: string): string;
+export declare function formatServerLookupError(result: Exclude<ServerLookupResult, {
+    status: 'found';
+}>): string;
+export declare function withLspClient<T>(filePath: string, fn: (client: LSPClient) => Promise<T>): Promise<T>;
+export declare function formatLocation(loc: Location | LocationLink): string;
+export declare function formatSymbolKind(kind: number): string;
+export declare function formatSeverity(severity: number | undefined): string;
+export declare function formatDiagnostic(diag: Diagnostic): string;
+export declare function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: 'error' | 'warning' | 'information' | 'hint' | 'all'): Diagnostic[];
+export interface ApplyResult {
+    success: boolean;
+    filesModified: string[];
+    totalEdits: number;
+    errors: string[];
+}
+export declare function applyWorkspaceEdit(edit: WorkspaceEdit | null): ApplyResult;
+export declare function formatApplyResult(result: ApplyResult): string;

package/dist/utils/agent-variant.d.ts

@@ -0,0 +1,47 @@
+import type { PluginConfig } from '../config';
+/**
+ * Normalizes an agent name by trimming whitespace and removing the optional @ prefix.
+ *
+ * @param agentName - The agent name to normalize (e.g., "@oracle" or "oracle")
+ * @returns The normalized agent name without @ prefix and trimmed of whitespace
+ *
+ * @example
+ * normalizeAgentName("@oracle") // returns "oracle"
+ * normalizeAgentName("  explore  ") // returns "explore"
+ */
+export declare function normalizeAgentName(agentName: string): string;
+/**
+ * Resolves the variant configuration for a specific agent.
+ *
+ * Looks up the agent's variant in the plugin configuration. Returns undefined if:
+ * - No config is provided
+ * - The agent has no variant configured
+ * - The variant is not a string
+ * - The variant is empty or whitespace-only
+ *
+ * @param config - The plugin configuration object
+ * @param agentName - The name of the agent (with or without @ prefix)
+ * @returns The trimmed variant string, or undefined if no valid variant is found
+ *
+ * @example
+ * resolveAgentVariant(config, "@oracle") // returns "high" if configured
+ */
+export declare function resolveAgentVariant(config: PluginConfig | undefined, agentName: string): string | undefined;
+/**
+ * Applies a variant to a request body if the body doesn't already have one.
+ *
+ * This function will NOT override an existing variant in the body. If no variant
+ * is provided or the body already has a variant, the original body is returned.
+ *
+ * @template T - The type of the body object, must have an optional variant property
+ * @param variant - The variant string to apply (or undefined)
+ * @param body - The request body object
+ * @returns The body with the variant applied (new object) or the original body unchanged
+ *
+ * @example
+ * applyAgentVariant("high", { agent: "oracle" }) // returns { agent: "oracle", variant: "high" }
+ * applyAgentVariant("high", { agent: "oracle", variant: "low" }) // returns original body with variant: "low"
+ */
+export declare function applyAgentVariant<T extends {
+    variant?: string;
+}>(variant: string | undefined, body: T): T;

package/dist/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(name: string): string | undefined;

package/dist/utils/file-io.d.ts

@@ -0,0 +1,3 @@
+export declare function writeTextFile(filePath: string, contents: string | ArrayBuffer): Promise<void>;
+export declare function readTextFile(filePath: string): Promise<string>;
+export declare function readTextFilePrefix(filePath: string, maxBytes: number): Promise<string>;

package/dist/utils/frontmatter-yaml.d.ts

@@ -0,0 +1,4 @@
+type YamlValue = string | null;
+export declare function stringifyYamlRecord(record: Record<string, YamlValue>): string;
+export declare function parseYamlRecord(source: string): Record<string, YamlValue>;
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './agent-variant';
+export * from './env';
+export * from './internal-initiator';
+export { log } from './logger';
+export * from './polling';
+export * from './tmux';
+export { extractZip } from './zip-extractor';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,6 @@
+export declare const LITE_INTERNAL_INITIATOR_MARKER = "<!-- LITE_INTERNAL_INITIATOR -->";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+};
+export declare function hasInternalInitiatorMarker(part: unknown): boolean;

package/dist/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(message: string, data?: unknown): void;

package/dist/utils/polling.d.ts

@@ -0,0 +1,21 @@
+export interface PollOptions {
+    pollInterval?: number;
+    maxPollTime?: number;
+    stableThreshold?: number;
+    signal?: AbortSignal;
+}
+export interface PollResult<T> {
+    success: boolean;
+    data?: T;
+    timedOut?: boolean;
+    aborted?: boolean;
+}
+/**
+ * Generic polling utility that waits for a condition to be met.
+ * Returns when the condition is satisfied or timeout/abort occurs.
+ */
+export declare function pollUntilStable<T>(fetchFn: () => Promise<T>, isStable: (current: T, previous: T | null, stableCount: number) => boolean, opts?: PollOptions): Promise<PollResult<T>>;
+/**
+ * Simple delay utility
+ */
+export declare function delay(ms: number): Promise<void>;

package/dist/utils/subprocess.d.ts

@@ -0,0 +1,24 @@
+type SpawnOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    stdin?: 'pipe' | 'ignore';
+    stdout?: 'pipe' | 'ignore';
+    stderr?: 'pipe' | 'ignore';
+};
+export type ManagedSubprocess = {
+    stdin: {
+        write(chunk: Uint8Array | string): unknown;
+        end(): unknown;
+    };
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    exitCode: number | null;
+    kill(): void;
+};
+export type ManagedSpawnSyncResult = {
+    exitCode: number | null;
+};
+export declare function spawn(command: string[], options?: SpawnOptions): ManagedSubprocess;
+export declare function spawnSync(command: string[], options?: SpawnOptions): ManagedSpawnSyncResult;
+export {};