@sayknow-cli/coding-agent 0.3.6 → 0.3.7

package/dist/types/discovery/helpers.d.ts

@@ -0,0 +1,271 @@
+import type { ThinkingLevel } from "@sayknow-cli/agent-core";
+import type { ExtensionModule } from "../capability/extension-module";
+import { type Rule } from "../capability/rule";
+import type { Skill } from "../capability/skill";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import type { ForkContextPolicy } from "../task/types";
+/**
+ * Standard paths for each config source.
+ */
+export declare const SOURCE_PATHS: {
+    readonly native: {
+        readonly userBase: string;
+        readonly userAgent: string;
+        projectDir: string;
+    };
+    readonly claude: {
+        readonly userBase: ".claude";
+        readonly userAgent: ".claude";
+        readonly projectDir: ".claude";
+    };
+    readonly codex: {
+        readonly userBase: ".codex";
+        readonly userAgent: ".codex";
+        readonly projectDir: ".codex";
+    };
+    readonly gemini: {
+        readonly userBase: ".gemini";
+        readonly userAgent: ".gemini";
+        readonly projectDir: ".gemini";
+    };
+    readonly opencode: {
+        readonly userBase: ".config/opencode";
+        readonly userAgent: ".config/opencode";
+        readonly projectDir: ".opencode";
+    };
+    readonly cursor: {
+        readonly userBase: ".cursor";
+        readonly userAgent: ".cursor";
+        readonly projectDir: ".cursor";
+    };
+    readonly windsurf: {
+        readonly userBase: ".codeium/windsurf";
+        readonly userAgent: ".codeium/windsurf";
+        readonly projectDir: ".windsurf";
+    };
+    readonly cline: {
+        readonly userBase: ".cline";
+        readonly userAgent: ".cline";
+        readonly projectDir: null;
+    };
+    readonly github: {
+        readonly userBase: null;
+        readonly userAgent: null;
+        readonly projectDir: ".github";
+    };
+    readonly vscode: {
+        readonly userBase: ".vscode";
+        readonly userAgent: ".vscode";
+        readonly projectDir: ".vscode";
+    };
+};
+export type SourceId = keyof typeof SOURCE_PATHS;
+/**
+ * Get user-level path for a source.
+ */
+export declare function getUserPath(ctx: LoadContext, source: SourceId, subpath: string): string | null;
+/**
+ * Get project-level path for a source (cwd only).
+ */
+export declare function getProjectPath(ctx: LoadContext, source: SourceId, subpath: string): string | null;
+/**
+ * Create source metadata for an item.
+ */
+export declare function createSourceMeta(provider: string, filePath: string, level: "user" | "project"): SourceMeta;
+export declare function parseBoolean(value: unknown): boolean | undefined;
+/**
+ * Parse a comma-separated string into an array of trimmed, non-empty strings.
+ */
+export declare function parseCSV(value: string): string[];
+/**
+ * Parse a value that may be an array of strings or a comma-separated string.
+ * Returns undefined if the result would be empty.
+ */
+export declare function parseArrayOrCSV(value: unknown): string[] | undefined;
+/**
+ * Build a canonical rule item from a markdown/markdown-frontmatter document.
+ */
+export declare function buildRuleFromMarkdown(name: string, content: string, filePath: string, source: SourceMeta, options?: {
+    ruleName?: string;
+    stripNamePattern?: RegExp;
+}): Rule;
+/**
+ * Parse model field into a prioritized list.
+ */
+export declare function parseModelList(value: unknown): string[] | undefined;
+/** Parsed agent fields from frontmatter (excludes source/filePath/systemPrompt) */
+export interface ParsedAgentFields {
+    name: string;
+    description: string;
+    tools?: string[];
+    spawns?: string[] | "*";
+    model?: string[];
+    output?: unknown;
+    thinkingLevel?: ThinkingLevel;
+    autoloadSkills?: string[];
+    blocking?: boolean;
+    hide?: boolean;
+    forkContext?: ForkContextPolicy;
+    bashAllowedPrefixes?: string[];
+}
+/**
+ * Parse agent fields from frontmatter.
+ * Returns null if required fields (name, description) are missing.
+ */
+export declare function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAgentFields | null;
+export interface ScanSkillsFromDirOptions {
+    dir: string;
+    providerId: string;
+    level: "user" | "project";
+    requireDescription?: boolean;
+}
+export declare function compareSkillOrder(aName: string, aPath: string, bName: string, bPath: string): number;
+export declare function scanSkillsFromDir(_ctx: LoadContext, options: ScanSkillsFromDirOptions): Promise<LoadResult<Skill>>;
+/**
+ * Recursively expand environment variables in an object.
+ */
+export declare function expandEnvVarsDeep<T>(obj: T, extraEnv?: Record<string, string>): T;
+/**
+ * Load files from a directory matching extensions.
+ * Uses native glob for fast filesystem scanning with gitignore support.
+ */
+export declare function loadFilesFromDir<T>(_ctx: LoadContext, dir: string, provider: string, level: "user" | "project", options: {
+    /** File extensions to match (without dot) */
+    extensions?: string[];
+    /** Transform file to item (return null to skip) */
+    transform: (name: string, content: string, path: string, source: SourceMeta) => T | null;
+    /** Whether to recurse into subdirectories (default: false) */
+    recursive?: boolean;
+}): Promise<LoadResult<T>>;
+/**
+ * Calculate depth of target directory relative to current working directory.
+ * Depth is the number of directory levels from cwd to target.
+ * - Positive depth: target is above cwd (parent/ancestor)
+ * - Zero depth: target is cwd
+ * - This uses path splitting to count directory levels
+ */
+export declare function calculateDepth(cwd: string, targetDir: string, separator: string): number;
+/**
+ * Discover extension module entry points in a directory.
+ *
+ * Discovery rules:
+ * 1. Direct files: `extensions/*.ts` or `*.js` → load
+ * 2. Subdirectory with index: `extensions/<ext>/index.ts` or `index.js` → load
+ * 3. Subdirectory with package.json: `extensions/<ext>/package.json` with "skc"/"pi" field → load declared paths
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ * Uses native glob for fast filesystem scanning with gitignore support.
+ */
+export declare function discoverExtensionModulePaths(_ctx: LoadContext, dir: string): Promise<string[]>;
+/**
+ * Derive a stable extension name from a path.
+ */
+export declare function getExtensionNameFromPath(extensionPath: string): string;
+/**
+ * Build ExtensionModule items from discovered user/project paths.
+ * Shared across providers that expose extension modules via user + project dirs.
+ */
+export declare function buildExtensionModuleItems(providerId: string, userPaths: string[], projectPaths: string[]): ExtensionModule[];
+/**
+ * Entry for an installed Anthropic Code plugin.
+ */
+export interface ClaudePluginEntry {
+    scope: "user" | "project";
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+    enabled?: boolean;
+}
+/**
+ * Anthropic Code installed_plugins.json registry format.
+ */
+export interface ClaudePluginsRegistry {
+    version: number;
+    plugins: Record<string, ClaudePluginEntry[]>;
+}
+/**
+ * Resolved plugin root for loading.
+ */
+export interface ClaudePluginRoot {
+    /** Plugin ID (e.g., "simpleAnthropic model-core@simpleAnthropic model") */
+    id: string;
+    /** Marketplace name */
+    marketplace: string;
+    /** Plugin name */
+    plugin: string;
+    /** Version string */
+    version: string;
+    /** Absolute path to plugin root */
+    path: string;
+    /** Whether this is a user or project scope plugin */
+    scope: "user" | "project";
+}
+/**
+ * Parse Anthropic Code installed_plugins.json content.
+ */
+export declare function parseClaudePluginsRegistry(content: string): ClaudePluginsRegistry | null;
+/**
+ * Resolve the active project registry path by walking up from `cwd`.
+ *
+ * Walk order:
+ * 1. Walk up from `cwd` looking for the nearest directory containing `.skc/`.
+ *    The first match returns `<dir>/.skc/plugins/installed_plugins.json`.
+ * 2. If no `.skc/` is found, rescan from `cwd` upward looking for `.git`.
+ *    The git root is used as an anchor: `<gitRoot>/.skc/plugins/installed_plugins.json`.
+ * 3. If neither is found, return `null` — no project context is active.
+ *
+ * This is the single source of truth for "active project root" used by install,
+ * uninstall, list, upgrade, discovery, and doctor. Deterministic for a given `cwd`.
+ */
+export declare function resolveActiveProjectRegistryPath(cwd: string): Promise<string | null>;
+/**
+ * Like resolveActiveProjectRegistryPath, but falls back to `<cwd>/.skc/plugins/installed_plugins.json`
+ * when no project anchor (.skc/ or .git/) is found.
+ *
+ * Use this when the caller accepts an explicit --scope project so that installing into a freshly
+ * bootstrapped directory (no .skc/ or .git/ yet) works: writeInstalledPluginsRegistry auto-creates
+ * the directory tree on first write.
+ *
+ * Returns undefined when cwd is os.homedir() — that path is already the user registry and must
+ * never alias as the project registry.
+ */
+export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined>;
+/**
+ * List installed SKC plugin roots from the SKC plugin registry and, when present,
+ * the nearest project-scoped registry resolved from `cwd`.
+ *
+ * Results are cached per `home:resolvedProjectPath` key to avoid repeated parsing.
+ */
+export declare function listClaudePluginRoots(home: string, cwd?: string): Promise<{
+    roots: ClaudePluginRoot[];
+    warnings: string[];
+}>;
+/**
+ * Clear the plugin roots cache (useful for testing or when plugins change).
+ */
+export declare function clearClaudePluginRootsCache(): void;
+/**
+ * Invalidate fs caches for installed-plugin registry files and reset the
+ * in-memory plugin roots cache. Used by MarketplaceManager clients after
+ * installing/uninstalling/enabling/disabling plugins.
+ */
+export declare function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void;
+/**
+ * Populate the module-level plugin roots cache for sync consumers.
+ * Call during session initialization, after dir resolution completes
+ * but before any LSP config is read.
+ */
+export declare function preloadPluginRoots(home: string, cwd?: string): Promise<void>;
+/**
+ * Get pre-loaded plugin roots synchronously.
+ * Returns empty array if preloadPluginRoots() hasn't been called.
+ */
+export declare function getPreloadedPluginRoots(): readonly ClaudePluginRoot[];
+/**
+ * Inject synthetic plugin roots from --plugin-dir paths.
+ * These are prepended to the cache with highest precedence (before SKC/Anthropic model entries).
+ * Must be called before any listAnthropic modelPluginRoots() access.
+ */
+export declare function injectPluginDirRoots(home: string, dirs: string[], cwd?: string): Promise<void>;

package/dist/types/discovery/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Discovery Module
+ *
+ * Auto-registers all providers by importing them.
+ * Import this module to ensure all providers are registered with the capability registry.
+ */
+import "../capability/context-file";
+import "../capability/extension";
+import "../capability/extension-module";
+import "../capability/hook";
+import "../capability/instruction";
+import "../capability/mcp";
+import "../capability/prompt";
+import "../capability/rule";
+import "../capability/settings";
+import "../capability/skill";
+import "../capability/slash-command";
+import "../capability/ssh";
+import "../capability/system-prompt";
+import "../capability/tool";
+import "./agents-md";
+import "./builtin";
+import "./cline";
+import "./agents";
+import "./cursor";
+import "./gemini";
+import "./opencode";
+import "./github";
+import "./mcp-json";
+import "./ssh";
+import "./windsurf";
+export { cacheStats, disableProvider, enableProvider, getAllCapabilitiesInfo, getAllProvidersInfo, getCapability, getCapabilityInfo, getDisabledProviders, getProviderInfo, initializeWithSettings, invalidate, isProviderEnabled, listCapabilities, loadCapability, reset, setDisabledProviders, } from "../capability";
+export type { ContextFile } from "../capability/context-file";
+export type { Extension, ExtensionManifest } from "../capability/extension";
+export type { ExtensionModule } from "../capability/extension-module";
+export type { Hook } from "../capability/hook";
+export type { Instruction } from "../capability/instruction";
+export type { MCPServer } from "../capability/mcp";
+export type { Prompt } from "../capability/prompt";
+export type { Rule, RuleFrontmatter } from "../capability/rule";
+export type { Settings } from "../capability/settings";
+export type { Skill, SkillFrontmatter } from "../capability/skill";
+export type { SlashCommand } from "../capability/slash-command";
+export type { SSHHost } from "../capability/ssh";
+export type { SystemPrompt } from "../capability/system-prompt";
+export type { CustomTool } from "../capability/tool";
+export type * from "../capability/types";

package/dist/types/discovery/mcp-json.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/opencode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/plugin-dir-roots.d.ts

@@ -0,0 +1,15 @@
+/** Synthetic plugin root for a --plugin-dir path. Shape-compatible with Anthropic modelPluginRoot. */
+export interface PluginDirRoot {
+    id: string;
+    marketplace: string;
+    plugin: string;
+    version: string;
+    path: string;
+    scope: "user" | "project";
+}
+/**
+ * Build a synthetic plugin root from a --plugin-dir resolved path.
+ * @param resolvedPath Absolute path to the plugin directory
+ * @param manifestName Plugin name from manifest; falls back to directory basename
+ */
+export declare function buildPluginDirRoot(resolvedPath: string, manifestName?: string): PluginDirRoot;

package/dist/types/discovery/ssh.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Recursively substitute ${ANTHROPIC_MODEL_PLUGIN_ROOT} and ${SKC_PLUGIN_ROOT}
+ * with the actual plugin root path in strings, arrays, and plain objects.
+ */
+export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;

package/dist/types/discovery/vscode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/windsurf.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Windsurf (Codeium) Provider
+ *
+ * Loads configuration from Windsurf's config locations:
+ * - User: ~/.codeium/windsurf
+ * - Project: .windsurf
+ *
+ * Supports:
+ * - Rules from .windsurf/rules/*.md and ~/.codeium/windsurf/memories/global_rules.md
+ * - Legacy .windsurfrules file
+ *
+ * MCP servers are intentionally NOT inherited live from Windsurf config: SKC
+ * owns MCP runtime execution. Copy definitions into SKC's own mcp.json instead.
+ */
+export {};

package/dist/types/edit/apply-patch/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Multi-file orchestrator for the OpenAI code backend `apply_patch` envelope.
+ *
+ * Decoupled from tool-registration: takes raw patch text + options, parses
+ * it, and applies each hunk via the existing single-file `applyPatch` in
+ * `../modes/patch.ts`. A future OpenAI freeform/grammar tool variant can
+ * call this directly with the raw grammar output.
+ *
+ * Per spec §6.1, hunks are applied in order and NOT atomically — if hunk
+ * N fails, hunks `0..N-1` are already on disk. We surface that by
+ * returning the per-file results alongside the error when it happens.
+ */
+import { type ApplyPatchOptions, type ApplyPatchResult } from "../modes/patch";
+export * from "./parser";
+export interface ApplyCodexPatchResult {
+    /** Single-file apply results in the order they were attempted. */
+    results: ApplyPatchResult[];
+    /** Affected file paths grouped by operation, for the §9.1 summary. */
+    affected: {
+        added: string[];
+        modified: string[];
+        deleted: string[];
+    };
+}
+/**
+ * Apply a full OpenAI code backend `*** Begin Patch` envelope.
+ *
+ * Note: renames are reported under `modified` with the original path (spec
+ * §9.1), not as a delete + add.
+ */
+export declare function applyCodexPatch(patchText: string, options: ApplyPatchOptions): Promise<ApplyCodexPatchResult>;
+/**
+ * Format the A/M/D summary described in spec §9.1.
+ */
+export declare function formatApplyCodexPatchSummary(affected: ApplyCodexPatchResult["affected"]): string;

package/dist/types/edit/apply-patch/parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for the OpenAI code backend `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+import type { PatchInput } from "../modes/patch";
+/**
+ * Parse a OpenAI code backend `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export declare function parseApplyPatch(patchText: string): PatchInput[];
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export declare function parseApplyPatchStreaming(patchText: string): PatchInput[];

package/dist/types/edit/diff.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Diff generation and replace-mode utilities for the edit tool.
+ *
+ * Provides diff string generation and the replace-mode edit logic
+ * used when not in patch mode.
+ */
+export interface DiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface DiffError {
+    error: string;
+}
+export interface DiffHunk {
+    changeContext?: string;
+    oldStartLine?: number;
+    newStartLine?: number;
+    hasContextLines: boolean;
+    oldLines: string[];
+    newLines: string[];
+    isEndOfFile: boolean;
+}
+export declare class ParseError extends Error {
+    readonly lineNumber?: number | undefined;
+    constructor(message: string, lineNumber?: number | undefined);
+}
+export declare class ApplyPatchError extends Error {
+    constructor(message: string);
+}
+type DiffLinePart = {
+    added?: boolean;
+    removed?: boolean;
+    value: string;
+};
+type DiffLinesFn = (oldStr: string, newStr: string) => DiffLinePart[];
+export declare function __setDiffLinesForTest(diffLines: DiffLinesFn | null): void;
+export declare function __clearDiffLinesForTest(): void;
+export declare function __getNativeDiffLinesForTest(): DiffLinesFn | undefined;
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export interface ReplaceOptions {
+    /** Allow fuzzy matching */
+    fuzzy: boolean;
+    /** Replace all occurrences */
+    all: boolean;
+    /** Similarity threshold for fuzzy matching */
+    threshold?: number;
+}
+export interface ReplaceResult {
+    /** The new content after replacements */
+    content: string;
+    /** Number of replacements made */
+    count: number;
+}
+/**
+ * Generate a unified diff string without file headers.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export declare function normalizeDiff(diff: string): string;
+export declare function normalizeCreateContent(content: string): string;
+export declare function parseDiffHunks(diff: string): DiffHunk[];
+/**
+ * Find and replace text in content using fuzzy matching.
+ */
+export declare function replaceText(content: string, oldText: string, newText: string, options: ReplaceOptions): ReplaceResult;
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string, fuzzy?: boolean, all?: boolean, threshold?: number): Promise<DiffResult | DiffError>;
+export {};

package/dist/types/edit/file-read-cache.d.ts

@@ -0,0 +1,25 @@
+import type { ToolSession } from "../tools";
+export interface FileReadSnapshot {
+    /** 1-indexed line number → exact line content as observed by `read`/`search`. */
+    lines: Map<number, string>;
+    recordedAt: number;
+}
+export declare class FileReadCache {
+    #private;
+    /** Look up the most recent snapshot for `absPath`, or `null` if absent. */
+    get(absPath: string): FileReadSnapshot | null;
+    /** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
+    recordContiguous(absPath: string, startLine: number, lines: readonly string[]): void;
+    /** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
+    recordSparse(absPath: string, entries: Iterable<readonly [number, string]>): void;
+    /** Drop the snapshot for a single path. */
+    invalidate(absPath: string): void;
+    /** Drop every snapshot. */
+    clear(): void;
+}
+/**
+ * Look up (or lazily create) the file-read cache attached to a session. The
+ * cache is stored as `session.fileReadCache` so it lives exactly as long as
+ * the session itself.
+ */
+export declare function getFileReadCache(session: ToolSession): FileReadCache;

package/dist/types/edit/index.d.ts

@@ -0,0 +1,58 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type * as z from "zod/v4";
+import { type HashlineParams, hashlineEditParamsSchema } from "../hashline";
+import type { ToolSession } from "../tools";
+import { vimSchema } from "../tools/vim";
+import { type EditMode } from "../utils/edit-mode";
+import type { VimToolDetails } from "../vim/types";
+import { type ApplyPatchParams, applyPatchSchema } from "./modes/apply-patch";
+import { type PatchParams, patchEditSchema } from "./modes/patch";
+import { type ReplaceParams, replaceEditSchema } from "./modes/replace";
+import { type EditToolDetails } from "./renderer";
+export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
+export * from "./apply-patch";
+export * from "./diff";
+export * from "./file-read-cache";
+export * from "../hashline";
+export * from "./modes/apply-patch";
+export * from "./modes/patch";
+export * from "./modes/replace";
+export * from "./normalize";
+export * from "./renderer";
+export * from "./streaming";
+type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema | typeof vimSchema | typeof applyPatchSchema;
+type VimParams = z.infer<typeof vimSchema>;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
+type EditToolResultDetails = EditToolDetails | VimToolDetails;
+export declare class EditTool implements AgentTool<TInput> {
+    #private;
+    private readonly session;
+    readonly name = "edit";
+    readonly label = "Edit";
+    readonly loadMode = "essential";
+    readonly nonAbortable = true;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    constructor(session: ToolSession);
+    get mode(): EditMode;
+    get description(): string;
+    get parameters(): TInput;
+    /**
+     * When in `apply_patch` mode, expose the OpenAI code backend Lark grammar so providers
+     * that support OpenAI-style custom tools can emit a grammar-constrained
+     * variant. Providers that don't support custom tools ignore this field
+     * and fall back to emitting a JSON function tool from `parameters`.
+     */
+    get customFormat(): {
+        syntax: "lark";
+        definition: string;
+    } | undefined;
+    /**
+     * Wire-level tool name used when the custom-tool variant is active. GPT-5+
+     * is trained on the literal name `apply_patch`; internally this is just a
+     * mode of the `edit` tool. The agent-loop dispatcher matches both the
+     * internal `name` and `customWireName`, so returned calls route correctly.
+     */
+    get customWireName(): string | undefined;
+    execute(_toolCallId: string, params: EditParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<EditToolResultDetails, TInput>, context?: AgentToolContext): Promise<AgentToolResult<EditToolResultDetails, TInput>>;
+}

package/dist/types/edit/modes/apply-patch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Edit mode wrapper for the OpenAI code backend `apply_patch` envelope format.
+ *
+ * The mode accepts a single `input` string containing a full
+ * `*** Begin Patch ... *** End Patch` block, parses it, and fans out to
+ * the existing `executePatchSingle` — so all the machinery (plan mode,
+ * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
+ * the `patch` mode.
+ */
+import * as z from "zod/v4";
+import type { PatchEditEntry } from "./patch";
+export declare const applyPatchSchema: z.ZodObject<{
+    input: z.ZodString;
+}, z.core.$strip>;
+export type ApplyPatchParams = z.infer<typeof applyPatchSchema>;
+export type ApplyPatchEntry = PatchEditEntry & {
+    path: string;
+};
+/**
+ * Parse the envelope and lower each hunk to a `PatchEditEntry` so it can
+ * be routed through `executePatchSingle`.
+ */
+export declare function expandApplyPatchToEntries(params: ApplyPatchParams): ApplyPatchEntry[];
+export declare function expandApplyPatchToPreviewEntries(params: ApplyPatchParams): ApplyPatchEntry[];