jeopi-cli 16.2.13 → 16.2.14

package/dist/types/discovery/omp-extension-roots.d.ts

@@ -1,43 +0,0 @@
-import type { LoadContext } from "../capability/types";
-/** A resolved extension package directory wired into the discovery surfaces. */
-export interface OmpExtensionRoot {
-    /** Absolute path to the package directory. */
-    path: string;
-    /** Stable display name (basename of the package directory). */
-    name: string;
-    /** Scope from which the path was sourced. */
-    level: "user" | "project";
-}
-/**
- * Register CLI-provided extension package paths (e.g. from `--extension`/`-e`)
- * so the sub-discovery providers can find their sibling `skills/`, `hooks/`,
- * etc. Paths that do not resolve to a directory are silently dropped — file
- * entrypoints have no package sub-tree to scan.
- *
- * Call once during startup before any capability load. Repeated calls extend
- * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
- */
-export declare function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void;
-/** Drop every CLI-injected root. Tests use this between cases. */
-export declare function clearOmpExtensionCliRoots(): void;
-/** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
-export declare function getInjectedOmpExtensionCliRoots(): readonly OmpExtensionRoot[];
-/**
- * Resolve every configured extension package directory for the given context.
- *
- * Sources, in order of precedence (later entries with the same absolute path
- * are dropped):
- *
- * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
- * 2. Project `<cwd>/.omp/settings.json#extensions`
- * 3. User `~/.omp/agent/settings.json#extensions`
- * 4. Enabled npm/link plugins installed under `<plugins>/node_modules/` (for
- *    `jeopi install <pkg>` / `jeopi plugin install` / `jeopi plugin link`). Marketplace
- *    installs are loaded by the `claude-plugins` provider and are excluded here.
- * Only entries that resolve to a directory on disk are returned; file
- * entrypoints contribute zero sub-discovery surface and are filtered out.
- * Installed-plugin enumeration failures (missing lockfile, unreadable
- * `package.json`, etc.) are logged at `debug` and degrade gracefully — the
- * other sources still surface.
- */
-export declare function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]>;

package/dist/types/discovery/omp-plugins.d.ts

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

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

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

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

@@ -1,15 +0,0 @@
-/** Synthetic plugin root for a --plugin-dir path. Shape-compatible with ClaudePluginRoot. */
-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

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

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

@@ -1 +0,0 @@
-export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;

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

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

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

@@ -1,13 +0,0 @@
-/**
- * Windsurf (Codeium) Provider
- *
- * Loads configuration from Windsurf's config locations:
- * - User: ~/.codeium/windsurf
- * - Project: .windsurf
- *
- * Supports:
- * - MCP servers from mcp_config.json
- * - Rules from .windsurf/rules/*.md and ~/.codeium/windsurf/memories/global_rules.md
- * - Legacy .windsurfrules file
- */
-export {};

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

@@ -1,35 +0,0 @@
-/**
- * Multi-file orchestrator for the Codex `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 Codex `*** 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

@@ -1,34 +0,0 @@
-/**
- * Parser for the Codex `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 Codex `*** 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

@@ -1,60 +0,0 @@
-import { type BlockContextSource } from "../utils/block-context";
-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);
-}
-/**
- * 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, source?: BlockContextSource): 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, source?: BlockContextSource): 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>;

package/dist/types/edit/file-snapshot-store.d.ts

@@ -1,64 +0,0 @@
-import { InMemorySnapshotStore } from "jeopi-hashline";
-/**
- * Upper bound on the file size we snapshot. A section tag is a content hash of
- * the *whole* file, so minting one means holding the full normalized text in
- * the store. Files above this cap emit no `[path#tag]` header — line-anchored
- * editing of multi-megabyte files is out of scope under the full-content model.
- */
-export declare const SNAPSHOT_MAX_BYTES: number;
-interface FileSnapshotStoreOwner {
-    fileSnapshotStore?: InMemorySnapshotStore;
-}
-/**
- * Look up (or lazily create) the file snapshot store attached to a session.
- * Storage lives on `session.fileSnapshotStore` so it ages out exactly with
- * the session itself.
- */
-export declare function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemorySnapshotStore;
-/**
- * Canonicalize an absolute path into the stable key the snapshot store uses.
- *
- * Different code paths reach the snapshot store via different path forms:
- * `read local://foo.md` records under the file's `fs.realpath` (the local
- * protocol handler resolves symlinks); a subsequent `edit` may address the
- * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
- * via the absolute path returned in the `[path#tag]` header. macOS adds the
- * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
- * Collapsing every key through `realpath` makes those forms fuse onto one
- * snapshot entry, so a freshly-minted tag is never rejected as stale just
- * because the lookup spelled the same file differently.
- *
- * Non-existent paths (new-file writes) fall back to a realpath of the parent
- * directory + basename, then to the input. This keeps creates and updates on
- * the same canonical key.
- */
-export declare function canonicalSnapshotKey(absolutePath: string): string;
-/**
- * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
- * record it as a version snapshot, and return its content-hash tag. Returns
- * `undefined` when the file exceeds the cap or cannot be read — callers then
- * omit the section header so the model never sees a tag it can't anchor against.
- *
- * Producers that only displayed a slice of the file (range reads, search hits)
- * use this to mint a whole-file tag: the displayed lines stay partial, but the
- * tag fingerprints the entire file so a follow-up edit anchored at any line
- * validates whenever the live file is byte-identical to what was read.
- */
-export declare function recordFileSnapshot(session: FileSnapshotStoreOwner, absolutePath: string): Promise<string | undefined>;
-/**
- * The 1-indexed file lines a hashline-formatted body actually displayed.
- * Single `NN:` rows contribute that line; a collapsed summary `NN-MM:` row
- * (a `{ … }` brace pair) contributes only its boundary lines `NN` and `MM` —
- * the elided interior was never shown, so editing inside it must be rejected.
- */
-export declare function parseSeenLinesFromHashlineBody(body: string): number[];
-/** Merge explicit 1-indexed displayed lines into a recorded hashline snapshot. */
-export declare function recordSeenLines(session: FileSnapshotStoreOwner, absolutePath: string, tag: string, lines: readonly number[]): void;
-/**
- * Attach the lines a read displayed to the snapshot it minted, so the patcher
- * can reject edits anchored on lines the model never saw. Best-effort: a no-op
- * when the body has no numbered rows or the snapshot already aged out. `tag`
- * must be the tag returned when this exact content was recorded.
- */
-export declare function recordSeenLinesFromBody(session: FileSnapshotStoreOwner, absolutePath: string, tag: string, body: string): void;
-export {};

package/dist/types/edit/hashline/block-resolver.d.ts

@@ -1,9 +0,0 @@
-/**
- * Tree-sitter-backed {@link BlockResolver} for the hashline block replace
- * operator. Bridges the pure hashline seam to the native `blockRangeAt`
- * primitive in `jeopi-natives`, which infers the language from the file
- * path and returns the 1-indexed line span of the syntactic block beginning on
- * the requested line (or `null` when none can be resolved).
- */
-import type { BlockResolver } from "jeopi-hashline";
-export declare const nativeBlockResolver: BlockResolver;

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

@@ -1,29 +0,0 @@
-import { type PatchSection, type SnapshotStore } from "jeopi-hashline";
-export interface HashlineDiffOptions {
-    /**
-     * Use the streaming-tolerant applier ({@link PatchSection.applyPartialTo})
-     * so trailing in-flight ops do not throw or emit phantom edits. Streaming
-     * preview path only.
-     */
-    streaming?: boolean;
-    /**
-     * Skip snapshot-tag validation. Streaming previews use this so transient
-     * stale/missing tags do not flash re-read errors while the model is still
-     * authoring input; the final apply path still validates through Patcher.
-     */
-    skipHashValidation?: boolean;
-}
-export declare function computeHashlineSectionDiff(section: PatchSection, cwd: string, snapshots: SnapshotStore, options?: HashlineDiffOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;
-export declare function computeHashlineDiff(input: {
-    input: string;
-}, cwd: string, snapshots: SnapshotStore, options?: HashlineDiffOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;

package/dist/types/edit/hashline/execute.d.ts

@@ -1,28 +0,0 @@
-/**
- * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
- * the `edit` tool. Converts a `{input}` tool-call payload into a
- * fully-applied patch, wraps the result in the agent's
- * {@link AgentToolResult} shape, and attaches LSP diagnostics + `outputMeta`
- * for the renderer.
- *
- * Multi-section patches are preflighted up front via {@link Patcher.prepare}
- * so a partial batch never lands; the commit loop then narrows the LSP
- * batch's `flush` flag to true only for the final write so diagnostics
- * round-trip once.
- */
-import type { AgentToolResult } from "jeopi-agent-core";
-import { MismatchError as HashlineMismatchError } from "jeopi-hashline";
-import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
-import type { ToolSession } from "../../tools";
-import type { EditToolDetails, LspBatchRequest } from "../renderer";
-import { type HashlineParams, hashlineEditParamsSchema } from "./params";
-export interface ExecuteHashlineSingleOptions {
-    session: ToolSession;
-    input: string;
-    signal?: AbortSignal;
-    batchRequest?: LspBatchRequest;
-    writethrough: WritethroughCallback;
-    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
-}
-export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;
-export { HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

package/dist/types/edit/hashline/filesystem.d.ts

@@ -1,43 +0,0 @@
-import { Filesystem, type PreflightWriteOptions, type WriteResult } from "jeopi-hashline";
-import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
-import type { ToolSession } from "../../tools";
-import type { LspBatchRequest } from "../renderer";
-export interface HashlineFilesystemOptions {
-    session: ToolSession;
-    writethrough: WritethroughCallback;
-    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
-    signal?: AbortSignal;
-    /**
-     * Outer LSP batch request inherited from the tool-call context. The
-     * orchestrator narrows this per-section (flush only on the final write)
-     * via {@link HashlineFilesystem.setBatchRequest}.
-     */
-    batchRequest?: LspBatchRequest;
-}
-export declare class HashlineFilesystem extends Filesystem {
-    #private;
-    readonly session: ToolSession;
-    constructor(options: HashlineFilesystemOptions);
-    /**
-     * Set the LSP batch request used for the next {@link writeText} call.
-     * Multi-section orchestrators flip the `flush` flag to true before the
-     * final section so LSP diagnostics flush in one round-trip.
-     */
-    setBatchRequest(batchRequest: LspBatchRequest | undefined): void;
-    /**
-     * Look up (and clear) the diagnostics captured by the most-recent
-     * {@link writeText} call for `path`. Returns `undefined` if no write
-     * has happened or the writethrough returned no diagnostics.
-     */
-    consumeDiagnostics(path: string): FileDiagnosticsResult | undefined;
-    resolveAbsolute(relativePath: string): string;
-    canonicalPath(relativePath: string): string;
-    allowTagPathRecovery(authoredPath: string, resolvedPath: string): boolean;
-    readText(relativePath: string): Promise<string>;
-    readBinary(relativePath: string): Promise<Uint8Array | undefined>;
-    preflightWrite(relativePath: string, options?: PreflightWriteOptions): Promise<void>;
-    delete(relativePath: string): Promise<void>;
-    move(fromRelative: string, toRelative: string, content?: string): Promise<void>;
-    writeText(relativePath: string, content: string): Promise<WriteResult>;
-    exists(relativePath: string): Promise<boolean>;
-}

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

@@ -1,5 +0,0 @@
-export * from "./block-resolver";
-export * from "./diff";
-export * from "./execute";
-export * from "./filesystem";
-export * from "./params";

package/dist/types/edit/hashline/noop-loop-guard.d.ts

@@ -1,72 +0,0 @@
-/**
- * Per-session guard against subagents looping on byte-identical no-op edits.
- *
- * A hashline patch can apply cleanly yet produce no change when the body rows
- * are already byte-identical to the targeted lines. {@link executeHashlineSingle}
- * surfaces a soft hint ("re-read the file before issuing another edit"), but in
- * the wild some models ignore the hint and keep re-issuing the same bytes
- * (issue #2081 captured 182 such repeats in 205 calls before the user aborted).
- *
- * This module tracks consecutive byte-identical no-op edits per canonical file
- * path within a single session. Once the same payload no-ops {@link NOOP_HARD_LIMIT}
- * times in a row the caller is expected to escalate from a soft text result to
- * a thrown {@link ToolError} so the agent loop sees a tool *failure* — empirically
- * far more effective at breaking the cycle than the soft hint alone.
- *
- * A successful (non-noop) commit for a path resets that path's counter; a
- * different payload on the same path also resets it because the body hash
- * changed, which is a sign of model progress and deserves another soft hint.
- */
-interface NoopLoopEntry {
-    /** Hash of the most recent input that no-op'd on this canonical path. */
-    hash: string;
-    /** Consecutive no-op count for the same `hash` on this path. */
-    count: number;
-}
-/** Cross-session-safe state slot held on the `ToolSession`. */
-export interface NoopLoopGuard {
-    entries: Map<string, NoopLoopEntry>;
-}
-/**
- * After this many consecutive byte-identical no-op edits on the same path,
- * {@link recordNoopEdit} returns `escalate: true`. Picked deliberately small
- * so the soft hint still fires once or twice before we escalate — the model
- * deserves a chance to recover, but a tight bound is what actually breaks
- * loops in practice.
- */
-export declare const NOOP_HARD_LIMIT = 3;
-interface NoopLoopGuardOwner {
-    noopLoopGuard?: NoopLoopGuard;
-}
-/** Lazily create the per-session guard, mirroring `getFileSnapshotStore`. */
-export declare function getNoopLoopGuard(session: NoopLoopGuardOwner): NoopLoopGuard;
-/** Result of recording one no-op against the guard. */
-export interface NoopRecordResult {
-    /** Consecutive identical no-op count, including the current one. */
-    count: number;
-    /** True once `count >= NOOP_HARD_LIMIT` and the caller MUST escalate. */
-    escalate: boolean;
-}
-/**
- * Record a no-op edit for `canonicalPath` keyed by `inputHash` (a stable hash
- * of the raw patch input bytes). Returns the running consecutive-no-op count
- * and whether the caller should escalate from a soft text result to a thrown
- * error.
- *
- * `inputHash` is intentionally derived from the raw model-authored bytes
- * rather than from file content: when the model emits a different payload
- * (even whitespace-only) that's progress and earns a fresh soft hint, but
- * re-issuing the same bytes after being warned is what we want to break.
- */
-export declare function recordNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string, inputHash: string): NoopRecordResult;
-/**
- * Clear the no-op counter for `canonicalPath`. Call after a non-noop commit
- * for the same path so a future no-op starts fresh from the soft hint.
- */
-export declare function resetNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string): void;
-/**
- * Stable hash of the raw patch input. Bun's `Bun.hash` is xxHash64 — fast,
- * non-cryptographic, more than adequate for "is this the same payload?".
- */
-export declare function hashPatchInput(input: string): string;
-export {};

package/dist/types/edit/hashline/params.d.ts

@@ -1,7 +0,0 @@
-export declare const hashlineEditParamsSchema: import("arktype/internal/variants/object.ts").ObjectType<(In: {
-    input?: string | undefined;
-    _input?: string | undefined;
-}) => import("arktype/internal/attributes.ts").To<{
-    input: string;
-}>, {}>;
-export type HashlineParams = Parameters<typeof hashlineEditParamsSchema.assert>[0];

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

@@ -1,83 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
-import type { ToolExample } from "jeopi-ai";
-import type { ToolSession } from "../tools";
-import { type EditMode } from "../utils/edit-mode";
-import { hashlineEditParamsSchema } from "./hashline";
-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 * from "jeopi-hashline";
-export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
-export * from "./apply-patch";
-export * from "./diff";
-export * from "./file-snapshot-store";
-export * from "./hashline";
-export * from "./modes/apply-patch";
-export * from "./modes/patch";
-export * from "./modes/replace";
-export * from "./normalize";
-export * from "./renderer";
-export * from "./snapshot-details";
-export * from "./streaming";
-type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema | typeof applyPatchSchema;
-type HashlineParams = typeof hashlineEditParamsSchema.infer;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
-export declare class EditTool implements AgentTool<TInput> {
-    #private;
-    private readonly session;
-    readonly approval: (args: unknown) => "read" | "write";
-    readonly formatApprovalDetails: (args: unknown) => string[];
-    readonly name = "edit";
-    readonly label = "Edit";
-    readonly loadMode = "essential";
-    readonly concurrency = "exclusive";
-    readonly strict = true;
-    constructor(session: ToolSession);
-    get mode(): EditMode;
-    get description(): string;
-    get parameters(): TInput;
-    get examples(): readonly ToolExample[] | undefined;
-    /**
-     * When in `apply_patch` mode, expose the Codex 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;
-    /**
-     * Normalize streamed args into the source text this edit introduces, so
-     * stream matchers (TTSR rules) run against real file content instead of the
-     * mode-specific patch grammar.
-     */
-    matcherDigest(args: unknown): string | undefined;
-    /**
-     * Project the streamed args onto their target file paths so path-scoped
-     * stream matchers (e.g. TTSR `tool:edit(*.ts)` globs) match hashline and
-     * apply_patch edits even though the path lives in the wire payload (a
-     * section header / envelope marker) rather than a top-level argument.
-     */
-    matcherPaths(args: unknown): readonly string[] | undefined;
-    /**
-     * Per-file projection of the streamed args, splitting multi-section
-     * hashline / multi-hunk apply_patch payloads into one (path, digest) entry
-     * per touched file. Path-scoped stream matchers (TTSR) then evaluate each
-     * file in isolation, so a `tool:edit(*.ts)` rule never fires on text that
-     * actually belongs to a sibling Markdown hunk.
-     */
-    matcherEntries(args: unknown): readonly {
-        path: string;
-        digest: string;
-    }[] | undefined;
-    execute(_toolCallId: string, params: EditParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>, context?: AgentToolContext): Promise<AgentToolResult<EditToolDetails, TInput>>;
-}

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

@@ -1,23 +0,0 @@
-/**
- * Edit mode wrapper for the Codex `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 type { PatchEditEntry } from "./patch";
-export declare const applyPatchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    input: string;
-}, {}>;
-export type ApplyPatchParams = typeof applyPatchSchema.infer;
-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[];