jeopi-cli 16.2.13 → 16.2.14

package/dist/types/export/ttsr.d.ts

@@ -1,67 +0,0 @@
-import type { Rule } from "../capability/rule";
-import type { TtsrSettings } from "../config/settings";
-export type TtsrMatchSource = "text" | "thinking" | "tool";
-/** Context about the stream content currently being checked against TTSR rules. */
-export interface TtsrMatchContext {
-    source: TtsrMatchSource;
-    /** Tool name for tool argument deltas, e.g. "edit" or "write". */
-    toolName?: string;
-    /** Candidate file paths associated with the current stream chunk. */
-    filePaths?: string[];
-    /** Stable key to isolate buffering (for example a tool call ID). */
-    streamKey?: string;
-}
-export declare class TtsrManager {
-    #private;
-    constructor(settings?: TtsrSettings);
-    /** Add a TTSR rule to be monitored. */
-    addRule(rule: Rule): boolean;
-    /**
-     * Add a stream chunk to its scoped buffer and return matching rules.
-     *
-     * Buffers are isolated by source/tool key so matches don't bleed across
-     * assistant prose, thinking text, and unrelated tool argument streams.
-     */
-    checkDelta(delta: string, context: TtsrMatchContext): Rule[];
-    /**
-     * Replace the scoped buffer with a tool-provided normalized snapshot and
-     * return matching rules.
-     *
-     * Used for tools exposing `matcherDigest`: the digest is recomputed from the
-     * full (partial) arguments on every delta, so it replaces the buffer instead
-     * of being appended to it.
-     */
-    checkSnapshot(snapshot: string, context: TtsrMatchContext): Rule[];
-    /**
-     * Evaluate ast-grep `astCondition` rules against a reconstructed tool snapshot.
-     *
-     * Only edit/write tool streams reach here (AST conditions need a language, which
-     * we infer from the file extension on the tool's path argument). The snapshot is
-     * matched in memory by the native engine (`astMatch`), so this is async and
-     * intentionally throttled: identical consecutive snapshots (the common case when
-     * only non-source arguments change between deltas) are skipped.
-     */
-    checkAstSnapshot(snapshot: string, context: TtsrMatchContext): Promise<Rule[]>;
-    /** True when any registered rule carries ast-grep conditions. */
-    hasAstRules(): boolean;
-    /** Mark rules as injected (won't trigger again until conditions allow). */
-    markInjected(rulesToMark: Rule[]): void;
-    /** Mark rule names as injected (won't trigger again until conditions allow). */
-    markInjectedByNames(ruleNames: string[]): void;
-    /** Get names of all injected rules (for persistence). */
-    getInjectedRuleNames(): string[];
-    /** Restore injected state from a list of rule names. */
-    restoreInjected(ruleNames: string[]): void;
-    /** Reset stream buffers (called on new turn). */
-    resetBuffer(): void;
-    /** Check if any TTSR rules are registered. */
-    hasRules(): boolean;
-    /** All rules currently registered for TTSR monitoring, in registration order. */
-    getRules(): Rule[];
-    /** Increment message counter (call after each turn). */
-    incrementMessageCount(): void;
-    /** Get current message count. */
-    getMessageCount(): number;
-    /** Get settings. */
-    getSettings(): Required<TtsrSettings>;
-}

package/dist/types/extensibility/custom-commands/bundled/ci-green/index.d.ts

@@ -1,9 +0,0 @@
-import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
-import type { HookCommandContext } from "../../../../extensibility/hooks/types";
-export declare class GreenCommand implements CustomCommand {
-    private api;
-    name: string;
-    description: string;
-    constructor(api: CustomCommandAPI);
-    execute(_args: string[], _ctx: HookCommandContext): Promise<string>;
-}

package/dist/types/extensibility/custom-commands/bundled/review/index.d.ts

@@ -1,10 +0,0 @@
-import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
-import type { HookCommandContext } from "../../../../extensibility/hooks/types";
-export declare class ReviewCommand implements CustomCommand {
-    private api;
-    name: string;
-    description: string;
-    constructor(api: CustomCommandAPI);
-    execute(args: string[], ctx: HookCommandContext): Promise<string | undefined>;
-}
-export default ReviewCommand;

package/dist/types/extensibility/custom-commands/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./loader";
-export type * from "./types";

package/dist/types/extensibility/custom-commands/loader.d.ts

@@ -1,29 +0,0 @@
-import type { CustomCommandSource, CustomCommandsLoadResult } from "./types";
-export interface DiscoverCustomCommandsOptions {
-    /** Current working directory. Default: getProjectDir() */
-    cwd?: string;
-    /** Agent config directory. Default: from getAgentDir() */
-    agentDir?: string;
-}
-export interface DiscoverCustomCommandsResult {
-    /** Paths to command modules */
-    paths: Array<{
-        path: string;
-        source: CustomCommandSource;
-    }>;
-}
-/**
- * Discover custom command modules (TypeScript slash commands).
- * Markdown slash commands are handled by core/slash-commands.ts.
- */
-export declare function discoverCustomCommands(options?: DiscoverCustomCommandsOptions): Promise<DiscoverCustomCommandsResult>;
-export interface LoadCustomCommandsOptions {
-    /** Current working directory. Default: getProjectDir() */
-    cwd?: string;
-    /** Agent config directory. Default: from getAgentDir() */
-    agentDir?: string;
-}
-/**
- * Discover and load custom commands from standard locations.
- */
-export declare function loadCustomCommands(options?: LoadCustomCommandsOptions): Promise<CustomCommandsLoadResult>;

package/dist/types/extensibility/custom-commands/types.d.ts

@@ -1,112 +0,0 @@
-/**
- * Custom command types.
- *
- * Custom commands are TypeScript modules that define executable slash commands.
- * Unlike markdown commands which expand to prompts, custom commands can execute
- * arbitrary logic with full access to the hook context.
- */
-import type * as arktype from "arktype";
-import type * as zod from "zod/v4";
-import type { ExecOptions, ExecResult, HookCommandContext } from "../../extensibility/hooks/types";
-import type * as PiCodingAgent from "../../index";
-import type * as TypeBox from "../typebox";
-export type { ExecOptions, ExecResult, HookCommandContext };
-/**
- * API passed to custom command factory.
- * Similar to HookAPI but focused on command needs.
- */
-export interface CustomCommandAPI {
-    /** Current working directory */
-    cwd: string;
-    /** Execute a shell command */
-    exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
-    /** Injected zod-backed typebox shim (legacy/compat). */
-    typebox: typeof TypeBox;
-    /** Injected arktype module for validation in custom commands. */
-    arktype: typeof arktype;
-    /** Injected zod/v4 module for canonical command validation. */
-    zod: typeof zod;
-    /** Injected pi-coding-agent exports */
-    pi: typeof PiCodingAgent;
-}
-/**
- * Custom command definition.
- *
- * Commands can either:
- * - Return a string to be sent to the LLM as a prompt
- * - Return void/undefined to do nothing (fire-and-forget)
- *
- * @example
- * ```typescript
- * const factory: CustomCommandFactory = (pi) => ({
- *	  name: "deploy",
- *	  description: "Deploy current branch to staging",
- *	  async execute(args, ctx) {
- *		 const env = args[0] || "staging";
- *		 const confirmed = await ctx.ui.confirm("Deploy", `Deploy to ${env}?`);
- *		 if (!confirmed) return;
- *
- *		 const result = await pi.exec("./deploy.sh", [env]);
- *		 if (result.exitCode !== 0) {
- *			ctx.ui.notify(`Deploy failed: ${result.stderr}`, "error");
- *			return;
- *		 }
- *
- *		 ctx.ui.notify("Deploy successful!", "info");
- *		 // No return = no prompt sent to LLM
- *	  }
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Return a prompt to send to the LLM
- * const factory: CustomCommandFactory = (pi) => ({
- *	  name: "git:status",
- *	  description: "Show git status and suggest actions",
- *	  async execute(args, ctx) {
- *		 const result = await pi.exec("git", ["status", "--porcelain"]);
- *		 return `Here's the git status:\n\`\`\`\n${result.stdout}\`\`\`\nSuggest what to do next.`;
- *	  }
- * });
- * ```
- */
-export interface CustomCommand {
-    /** Command name (can include namespace like "git:commit") */
-    name: string;
-    /** Description shown in command autocomplete */
-    description: string;
-    /**
-     * Execute the command.
-     * @param args - Parsed command arguments
-     * @param ctx - Command context with UI and session control
-     * @returns String to send as prompt, or void for fire-and-forget
-     */
-    execute(args: string[], ctx: HookCommandContext): Promise<string | undefined> | string | undefined;
-}
-/**
- * Factory function that creates custom command(s).
- * Can return a single command or an array of commands.
- */
-export type CustomCommandFactory = (api: CustomCommandAPI) => CustomCommand | CustomCommand[] | Promise<CustomCommand | CustomCommand[]>;
-/** Source of a loaded custom command */
-export type CustomCommandSource = "bundled" | "user" | "project";
-/** Loaded custom command with metadata */
-export interface LoadedCustomCommand {
-    /** Original path to the command module */
-    path: string;
-    /** Resolved absolute path */
-    resolvedPath: string;
-    /** The command definition */
-    command: CustomCommand;
-    /** Where the command was loaded from */
-    source: CustomCommandSource;
-}
-/** Result from loading custom commands */
-export interface CustomCommandsLoadResult {
-    commands: LoadedCustomCommand[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-}

package/dist/types/extensibility/custom-tools/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Custom tools module.
- */
-export * from "./loader";
-export type * from "./types";
-export * from "./wrapper";

package/dist/types/extensibility/custom-tools/loader.d.ts

@@ -1,89 +0,0 @@
-import type { AgentToolResult } from "jeopi-agent-core";
-import type { HookUIContext } from "../../extensibility/hooks/types";
-import * as PiCodingAgent from "../../index";
-import type { LoadedCustomTool, ToolLoadError } from "./types";
-/** Tool path with optional source metadata, suitable for forwarding from a
- * parent session to a subagent so the subagent can re-bind tools to its own
- * `CustomToolAPI` without redoing the filesystem scan. */
-export interface ToolPathWithSource {
-    path: string;
-    source?: {
-        provider: string;
-        providerName: string;
-        level: "user" | "project";
-    };
-}
-/**
- * Loads custom tools from paths with conflict detection and error handling.
- *
- * Manages a shared API instance passed to all tool factories, providing access to
- * execution context, UI, logger, and injected dependencies. The UI context can be
- * updated after loading via setUIContext().
- */
-export declare class CustomToolLoader {
-    #private;
-    tools: LoadedCustomTool[];
-    errors: ToolLoadError[];
-    constructor(pi: typeof PiCodingAgent, cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
-        label: string;
-        sourceToolName: string;
-        apply(reason: string): Promise<AgentToolResult<unknown>>;
-        reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-    }) => void);
-    load(pathsWithSources: ToolPathWithSource[]): Promise<void>;
-    setUIContext(uiContext: HookUIContext, hasUI: boolean): void;
-}
-/**
- * Load all tools from configuration.
- * @param pathsWithSources - Array of tool paths with optional source metadata
- * @param cwd - Current working directory for resolving relative paths
- * @param builtInToolNames - Names of built-in tools to check for conflicts
- */
-export declare function loadCustomTools(pathsWithSources: ToolPathWithSource[], cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
-    label: string;
-    sourceToolName: string;
-    apply(reason: string): Promise<AgentToolResult<unknown>>;
-    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-}) => void): Promise<{
-    tools: LoadedCustomTool<import("jeopi-ai").TSchema, any>[];
-    errors: ToolLoadError[];
-    setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
-}>;
-/**
- * Collect the absolute tool-source paths to load, without importing or
- * binding factories. Hot path on session startup — the scan walks
- * `.omp/tools/`, `.claude/tools/`, the plugin tree, and any configured paths.
- *
- * Subagents reuse the parent's collected paths via the SDK's
- * `preloadedCustomToolPaths` option, then call `loadCustomTools` themselves
- * so each session re-binds factories with its own session-scoped
- * `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
- *
- * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
- * @param cwd - Current working directory
- */
-export declare function discoverCustomToolPaths(configuredPaths: string[], cwd: string): Promise<ToolPathWithSource[]>;
-/**
- * Discover and load tools from standard locations via capability system:
- * 1. User and project tools discovered by capability providers
- * 2. Installed plugins (~/.omp/plugins/node_modules/*)
- * 3. Explicitly configured paths from settings or CLI
- *
- * Composed of {@link discoverCustomToolPaths} (FS scan) + {@link loadCustomTools}
- * (per-session binding). Subagents skip the first step and just call
- * `loadCustomTools` against the parent's collected paths.
- *
- * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
- * @param cwd - Current working directory
- * @param builtInToolNames - Names of built-in tools to check for conflicts
- */
-export declare function discoverAndLoadCustomTools(configuredPaths: string[], cwd: string, builtInToolNames: string[], pushPendingAction?: (action: {
-    label: string;
-    sourceToolName: string;
-    apply(reason: string): Promise<AgentToolResult<unknown>>;
-    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-}) => void): Promise<{
-    tools: LoadedCustomTool<import("jeopi-ai").TSchema, any>[];
-    errors: ToolLoadError[];
-    setUIContext: (uiContext: HookUIContext, hasUI: boolean) => void;
-}>;

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -1,242 +0,0 @@
-/**
- * Custom tool types.
- *
- * Custom tools are TypeScript modules that define additional tools for the agent.
- * They can provide custom rendering for tool calls and results in the TUI.
- */
-import type { type as ArkType } from "arktype";
-import type { AgentToolResult, AgentToolUpdateCallback, ToolApproval, ToolApprovalDecision, ToolTier } from "jeopi-agent-core";
-import type { CompactionResult } from "jeopi-agent-core/compaction";
-import type { FetchImpl, Model, Static, TSchema } from "jeopi-ai";
-import type { Component } from "jeopi-tui";
-import type { logger as PiLogger } from "jeopi-utils";
-import type * as zod from "zod/v4";
-import type { Rule } from "../../capability/rule";
-import type { ModelRegistry } from "../../config/model-registry";
-import type { Settings } from "../../config/settings";
-import type { ExecOptions, ExecResult } from "../../exec/exec";
-import type { HookUIContext } from "../../extensibility/hooks/types";
-import type * as PiCodingAgent from "../../index";
-import type { Theme } from "../../modes/theme/theme";
-import type { ReadonlySessionManager } from "../../session/session-manager";
-import type { TodoItem } from "../../tools/todo";
-import type * as TypeBox from "../typebox";
-/** Alias for clarity */
-export type CustomToolUIContext = HookUIContext;
-export type { ExecOptions, ExecResult } from "../../exec/exec";
-/** Re-export for custom tools to use in execute signature */
-export type { AgentToolResult, AgentToolUpdateCallback, ToolApproval, ToolApprovalDecision, ToolTier };
-/** Pending action entry consumed by the hidden resolve tool */
-export interface CustomToolPendingAction {
-    /** Human-readable preview label shown in resolve flow */
-    label: string;
-    /** Apply callback invoked when resolve(action="apply") is called */
-    apply(reason: string): Promise<AgentToolResult<unknown>>;
-    /** Optional reject callback invoked when resolve(action="discard") is called */
-    reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-    /** Optional details metadata stored with the pending action */
-    details?: unknown;
-    /** Optional source tool name shown by resolve renderer (defaults to "custom_tool") */
-    sourceToolName?: string;
-}
-/** API passed to custom tool factory (stable across session changes) */
-export interface CustomToolAPI {
-    /** Current working directory */
-    cwd: string;
-    /** Execute a command */
-    exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
-    /** UI methods for user interaction (select, confirm, input, notify, custom) */
-    ui: CustomToolUIContext;
-    /** Whether UI is available (false in print/RPC mode) */
-    hasUI: boolean;
-    /** File logger for error/warning/debug messages */
-    logger: typeof PiLogger;
-    /** Injected typebox shim (legacy/compat — arktype-authored tools are preferred). */
-    typebox: typeof TypeBox;
-    /** Injected arktype module for arktype-authored custom tools. */
-    arktype: typeof ArkType;
-    /** Injected zod/v4 module for canonical parameter schemas. */
-    zod: typeof zod;
-    /** Injected pi-coding-agent exports */
-    pi: typeof PiCodingAgent;
-    /** Push a preview action that can later be resolved with the hidden resolve tool */
-    pushPendingAction(action: CustomToolPendingAction): void;
-}
-/**
- * Context passed to tool execute and onSession callbacks.
- * Provides access to session state and model information.
- */
-export interface CustomToolContext {
-    /** Session manager (read-only) */
-    sessionManager: ReadonlySessionManager;
-    /** Model registry - use for API key resolution and model retrieval */
-    modelRegistry: ModelRegistry;
-    /** Current model (may be undefined if no model is selected yet) */
-    model: Model | undefined;
-    /** Whether the agent is idle (not streaming) */
-    isIdle(): boolean;
-    /** Whether there are queued messages waiting to be processed */
-    hasQueuedMessages(): boolean;
-    /** Abort the current agent operation (fire-and-forget, does not wait) */
-    abort(): void;
-    /** Settings instance for the current session. Prefer over the global singleton. */
-    settings?: Settings;
-    /** Fetch implementation for outbound HTTP; defaults to global fetch when omitted. */
-    fetch?: FetchImpl;
-    /** Whether to auto-approve all destructive tool operations (--auto-approve CLI flag) */
-    autoApprove?: boolean;
-}
-/** Session event passed to onSession callback */
-export type CustomToolSessionEvent = {
-    /** Reason for the session event */
-    reason: "start" | "switch" | "branch" | "tree" | "shutdown";
-    /** Previous session file path, or undefined for "start" and "shutdown" */
-    previousSessionFile: string | undefined;
-} | {
-    reason: "auto_compaction_start";
-    trigger: "threshold" | "overflow" | "idle" | "incomplete";
-    action: "context-full" | "handoff" | "shake" | "snapcompact";
-} | {
-    reason: "auto_compaction_end";
-    action: "context-full" | "handoff" | "shake" | "snapcompact";
-    result: CompactionResult | undefined;
-    aborted: boolean;
-    willRetry: boolean;
-    errorMessage?: string;
-} | {
-    reason: "auto_retry_start";
-    attempt: number;
-    maxAttempts: number;
-    delayMs: number;
-    errorMessage: string;
-    errorId?: number;
-} | {
-    reason: "auto_retry_end";
-    success: boolean;
-    attempt: number;
-    finalError?: string;
-} | {
-    reason: "ttsr_triggered";
-    rules: Rule[];
-} | {
-    reason: "todo_reminder";
-    todos: TodoItem[];
-    attempt: number;
-    maxAttempts: number;
-};
-/** Rendering options passed to renderResult */
-export interface RenderResultOptions {
-    /** Whether the result view is expanded */
-    expanded: boolean;
-    /** Whether this is a partial/streaming result */
-    isPartial: boolean;
-    /** Current spinner frame index for animated elements (0-9, only provided during partial results) */
-    spinnerFrame?: number;
-}
-export type CustomToolResult<TDetails = any> = AgentToolResult<TDetails>;
-/**
- * Custom tool definition.
- *
- * Custom tools are standalone - they don't extend AgentTool directly.
- * When loaded, they are wrapped in an AgentTool for the agent to use.
- *
- * The execute callback receives a ToolContext with access to session state,
- * model registry, and current model.
- *
- * @example
- * ```typescript
- * const factory: CustomToolFactory = (pi) => ({
- *   name: "my_tool",
- *   label: "My Tool",
- *   description: "Does something useful",
- *   parameters: Type.Object({ input: Type.String() }),
- *
- *   async execute(toolCallId, params, onUpdate, ctx, signal) {
- *     // Access session state via ctx.sessionManager
- *     // Access model registry via ctx.modelRegistry
- *     // Current model via ctx.model
- *     return { content: [{ type: "text", text: "Done" }] };
- *   },
- *
- *   onSession(event, ctx) {
- *     if (event.reason === "shutdown") {
- *       // Cleanup
- *     }
- *     // Reconstruct state from ctx.sessionManager.getEntries()
- *   }
- * });
- * ```
- */
-export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
-    /** Tool name (used in LLM tool calls) */
-    name: string;
-    /** Human-readable label for UI */
-    label: string;
-    /** If true, tool is strictly typed and validated against the parameters schema before execution */
-    strict?: boolean;
-    /** Description for LLM */
-    description: string;
-    /** Parameter schema (arktype, TypeBox, or legacy formats). */
-    parameters: TParams;
-    /** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
-    hidden?: boolean;
-    /** If true, tool may stage deferred changes that require explicit resolve/discard. */
-    deferrable?: boolean;
-    /** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
-    mcpServerName?: string;
-    /** Original MCP tool name for discovery/search metadata. */
-    mcpToolName?: string;
-    /** Capability tier declaration used by approval gates. Omitted means "exec". */
-    approval?: ToolApproval;
-    /** Lines appended after the standard approval prompt header. */
-    formatApprovalDetails?: (args: unknown) => string | string[] | undefined;
-    /**
-     * Execute the tool.
-     * @param toolCallId - Unique ID for this tool call
-     * @param params - Parsed parameters matching the schema
-     * @param onUpdate - Callback for streaming partial results (for UI, not LLM)
-     * @param ctx - Context with session manager, model registry, and current model
-     * @param signal - Optional abort signal for cancellation
-     */
-    execute(toolCallId: string, params: Static<TParams>, onUpdate: AgentToolUpdateCallback<TDetails, TParams> | undefined, ctx: CustomToolContext, signal?: AbortSignal): Promise<AgentToolResult<TDetails, TParams>>;
-    /** Called on session lifecycle events - use to reconstruct state or cleanup resources */
-    onSession?: (event: CustomToolSessionEvent, ctx: CustomToolContext) => void | Promise<void>;
-    /** Custom rendering for tool call display - return a Component */
-    renderCall?: (args: Static<TParams>, options: RenderResultOptions, theme: Theme) => Component;
-    /** Custom rendering for tool result display - return a Component */
-    renderResult?: (result: CustomToolResult<TDetails>, options: RenderResultOptions, theme: Theme, args?: Static<TParams>) => Component;
-}
-/** Factory function that creates a custom tool or array of tools */
-export type CustomToolFactory = (pi: CustomToolAPI) => CustomTool<any, any> | CustomTool<any, any>[] | Promise<CustomTool<any, any> | CustomTool<any, any>[]>;
-/** Loaded custom tool with metadata and wrapped AgentTool */
-export interface LoadedCustomTool<TParams extends TSchema = TSchema, TDetails = any> {
-    /** Original path (as specified) */
-    path: string;
-    /** Resolved absolute path */
-    resolvedPath: string;
-    /** The original custom tool instance */
-    tool: CustomTool<TParams, TDetails>;
-    /** Source metadata (provider and level) */
-    source?: {
-        provider: string;
-        providerName: string;
-        level: "user" | "project";
-    };
-}
-/** Error with source metadata */
-export interface ToolLoadError {
-    path: string;
-    error: string;
-    source?: {
-        provider: string;
-        providerName: string;
-        level: "user" | "project";
-    };
-}
-/** Result from loading custom tools */
-export interface CustomToolsLoadResult {
-    tools: LoadedCustomTool[];
-    errors: ToolLoadError[];
-    /** Update the UI context for all loaded tools. Call when mode initializes. */
-    setUIContext(uiContext: CustomToolUIContext, hasUI: boolean): void;
-}

package/dist/types/extensibility/custom-tools/wrapper.d.ts

@@ -1,23 +0,0 @@
-/**
- * CustomToolAdapter wraps CustomTool instances into AgentTool for use with the agent.
- */
-import type { AgentTool, AgentToolUpdateCallback } from "jeopi-agent-core";
-import type { Static, TSchema } from "jeopi-ai";
-import type { Theme } from "../../modes/theme/theme";
-import type { CustomTool, CustomToolContext } from "./types";
-export declare class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme> implements AgentTool<TParams, TDetails, TTheme> {
-    private tool;
-    private getContext;
-    name: string;
-    label: string;
-    description: string;
-    parameters: TParams;
-    readonly strict: boolean | undefined;
-    constructor(tool: CustomTool<TParams, TDetails>, getContext: () => CustomToolContext);
-    execute(toolCallId: string, params: Static<TParams>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParams>, context?: CustomToolContext): Promise<import("jeopi-agent-core").AgentToolResult<TDetails, TParams>>;
-    /**
-     * Backward-compatible export of factory function for existing callers.
-     * Prefer CustomToolAdapter constructor directly.
-     */
-    static wrap<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>(tool: CustomTool<TParams, TDetails>, getContext: () => CustomToolContext): AgentTool<TParams, TDetails, TTheme>;
-}

package/dist/types/extensibility/extensions/compact-handler.d.ts

@@ -1,26 +0,0 @@
-/**
- * Helper for wiring the `compact` action of an {@link ExtensionContext}.
- *
- * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
- * takes two positional arguments `(instructions, options)`. This helper splits the
- * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
- */
-import type { Model } from "jeopi-ai";
-import type { CompactOptions } from "./types";
-interface CompactableSession {
-    compact(instructions?: string, options?: CompactOptions): Promise<unknown>;
-}
-export declare function runExtensionCompact(session: CompactableSession, instructionsOrOptions: string | CompactOptions | undefined): Promise<void>;
-interface SetModelCapableSession {
-    modelRegistry: {
-        getApiKey(model: Model): Promise<string | undefined>;
-    };
-    setModel(model: Model): Promise<unknown>;
-}
-/**
- * Helper for wiring the `setModel` action of an {@link ExtensionContext}.
- *
- * Returns false when no API key is available for the requested model.
- */
-export declare function runExtensionSetModel(session: SetModelCapableSession, model: Model): Promise<boolean>;
-export {};

package/dist/types/extensibility/extensions/get-commands-handler.d.ts

@@ -1,29 +0,0 @@
-/**
- * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
- *
- * Centralizes the union over the three slash-command sources the runtime
- * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
- * task executor) cannot drift:
- *   - extension-registered hook commands (`source: "extension"`)
- *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
- *     custom commands and MCP prompts (`source: "prompt"`)
- *   - skill commands derived from `session.skills`, gated on
- *     `skillsSettings.enableSkillCommands` (`source: "skill"`)
- *
- * Built-in slash commands are intentionally excluded; `getCommands()` is the
- * surface extensions use to discover dynamic commands they did not register
- * themselves. Each frontend (interactive-mode, ACP) prepends its own builtins.
- */
-import type { SkillsSettings } from "../../config/settings";
-import type { LoadedCustomCommand } from "../custom-commands";
-import { type Skill } from "../skills";
-import type { SlashCommandInfo } from "../slash-commands";
-import type { ExtensionRunner } from "./runner";
-interface CommandsCapableSession {
-    readonly extensionRunner?: ExtensionRunner;
-    readonly customCommands: ReadonlyArray<LoadedCustomCommand>;
-    readonly skills: ReadonlyArray<Skill>;
-    readonly skillsSettings?: SkillsSettings;
-}
-export declare function getSessionSlashCommands(session: CommandsCapableSession): SlashCommandInfo[];
-export {};

package/dist/types/extensibility/extensions/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Extension system for lifecycle events and custom tools.
- */
-export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
-export { discoverAndLoadExtensions, discoverExtensionPaths, ExtensionRuntimeNotInitializedError, loadExtensionFromFactory, loadExtensions, } from "./loader";
-export * from "./runner";
-export * from "./types";
-export * from "./wrapper";