@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

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

@@ -0,0 +1,58 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-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 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;
+    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 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 * 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[];

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

@@ -0,0 +1,99 @@
+/**
+ * Patch application logic for the edit tool.
+ *
+ * Applies parsed diff hunks to file content using fuzzy matching
+ * for robust handling of whitespace and formatting differences.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import { type WritethroughCallback, type WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+export type Operation = "create" | "delete" | "update";
+export interface PatchInput {
+    path: string;
+    op: Operation;
+    rename?: string;
+    diff?: string;
+}
+export interface FileSystem {
+    exists(path: string): Promise<boolean>;
+    read(path: string): Promise<string>;
+    readBinary?: (path: string) => Promise<Uint8Array>;
+    write(path: string, content: string): Promise<void>;
+    delete(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+}
+interface FileChange {
+    type: Operation;
+    path: string;
+    newPath?: string;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface ApplyPatchResult {
+    change: FileChange;
+    warnings?: string[];
+}
+export interface ApplyPatchOptions {
+    cwd: string;
+    dryRun?: boolean;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    fs?: FileSystem;
+}
+/** Default filesystem implementation using Bun APIs */
+export declare const defaultFileSystem: FileSystem;
+/**
+ * Apply a patch operation to the filesystem.
+ */
+export declare function applyPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+/**
+ * Preview what changes a patch would make without applying it.
+ */
+export declare function previewPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+export declare function computePatchDiff(input: PatchInput, cwd: string, options?: {
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+}): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;
+export declare const patchEditEntrySchema: z.ZodObject<{
+    op: z.ZodOptional<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        update: "update";
+    }>>;
+    rename: z.ZodOptional<z.ZodString>;
+    diff: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const patchEditSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        op: z.ZodOptional<z.ZodEnum<{
+            create: "create";
+            delete: "delete";
+            update: "update";
+        }>>;
+        rename: z.ZodOptional<z.ZodString>;
+        diff: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
+export type PatchParams = z.infer<typeof patchEditSchema>;
+export interface ExecutePatchSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: PatchEditEntry;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    writethrough: WritethroughCallback;
+    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+export declare function executePatchSingle(options: ExecutePatchSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof patchEditEntrySchema>>;
+export {};

package/dist/types/edit/modes/replace.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Fuzzy matching utilities for the edit tool.
+ *
+ * Provides both character-level and line-level fuzzy matching with progressive
+ * fallback strategies for finding text in files.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+export interface FuzzyMatch {
+    actualText: string;
+    startIndex: number;
+    startLine: number;
+    confidence: number;
+}
+export interface MatchOutcome {
+    match?: FuzzyMatch;
+    closest?: FuzzyMatch;
+    occurrences?: number;
+    occurrenceLines?: number[];
+    occurrencePreviews?: string[];
+    fuzzyMatches?: number;
+    dominantFuzzy?: boolean;
+}
+export type SequenceMatchStrategy = "exact" | "trim-trailing" | "trim" | "comment-prefix" | "unicode" | "prefix" | "substring" | "fuzzy" | "fuzzy-dominant" | "character";
+export interface SequenceSearchResult {
+    index: number | undefined;
+    confidence: number;
+    matchCount?: number;
+    matchIndices?: number[];
+    strategy?: SequenceMatchStrategy;
+}
+export type ContextMatchStrategy = "exact" | "trim" | "unicode" | "prefix" | "substring" | "fuzzy";
+export interface ContextLineResult {
+    index: number | undefined;
+    confidence: number;
+    matchCount?: number;
+    matchIndices?: number[];
+    strategy?: ContextMatchStrategy;
+}
+export declare class EditMatchError extends Error {
+    readonly path: string;
+    readonly searchText: string;
+    readonly closest: FuzzyMatch | undefined;
+    readonly options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    };
+    constructor(path: string, searchText: string, closest: FuzzyMatch | undefined, options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    });
+    static formatMessage(path: string, searchText: string, closest: FuzzyMatch | undefined, options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    }): string;
+}
+/** Default similarity threshold for fuzzy matching */
+export declare const DEFAULT_FUZZY_THRESHOLD = 0.95;
+/** Compute Levenshtein distance between two strings */
+export declare function levenshteinDistance(a: string, b: string): number;
+/** Compute similarity score between two strings (0 to 1) */
+export declare function similarity(a: string, b: string): number;
+/**
+ * Find a match for target text within content.
+ * Used primarily for replace-mode edits.
+ */
+export declare function findMatch(content: string, target: string, options: {
+    allowFuzzy: boolean;
+    threshold?: number;
+}): MatchOutcome;
+/**
+ * Find a sequence of pattern lines within content lines.
+ *
+ * Attempts matches with decreasing strictness:
+ * 1. Exact match
+ * 2. Trailing whitespace ignored
+ * 3. All whitespace trimmed
+ * 4. Unicode punctuation normalized
+ * 5. Prefix match (pattern is prefix of line)
+ * 6. Substring match (pattern is substring of line)
+ * 7. Fuzzy similarity match
+ *
+ * @param lines - The lines of the file content
+ * @param pattern - The lines to search for
+ * @param start - Starting index for the search
+ * @param eof - If true, prefer matching at end of file first
+ */
+export declare function seekSequence(lines: string[], pattern: string[], start: number, eof: boolean, options?: {
+    allowFuzzy?: boolean;
+}): SequenceSearchResult;
+export declare function findClosestSequenceMatch(lines: string[], pattern: string[], options?: {
+    start?: number;
+    eof?: boolean;
+}): {
+    index: number | undefined;
+    confidence: number;
+    strategy: SequenceMatchStrategy;
+};
+/**
+ * Find a context line in the file using progressive matching strategies.
+ *
+ * @param lines - The lines of the file content
+ * @param context - The context line to search for
+ * @param startFrom - Starting index for the search
+ */
+export declare function findContextLine(lines: string[], context: string, startFrom: number, options?: {
+    allowFuzzy?: boolean;
+    skipFunctionFallback?: boolean;
+}): ContextLineResult;
+export declare const replaceEditEntrySchema: z.ZodObject<{
+    old_text: z.ZodString;
+    new_text: z.ZodString;
+    all: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const replaceEditSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        old_text: z.ZodString;
+        new_text: z.ZodString;
+        all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
+export type ReplaceParams = z.infer<typeof replaceEditSchema>;
+export interface ExecuteReplaceSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: ReplaceEditEntry;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    writethrough: WritethroughCallback;
+    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+export declare function executeReplaceSingle(options: ExecuteReplaceSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof replaceEditEntrySchema>>;

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

@@ -0,0 +1,43 @@
+/**
+ * Text normalization utilities for the edit tool.
+ *
+ * Handles line endings, BOM, whitespace, and Unicode normalization.
+ */
+export type LineEnding = "\r\n" | "\n";
+/** Detect the predominant line ending in content */
+export declare function detectLineEnding(content: string): LineEnding;
+/** Normalize all line endings to LF */
+export declare function normalizeToLF(text: string): string;
+/** Restore line endings to the specified type */
+export declare function restoreLineEndings(text: string, ending: LineEnding): string;
+export interface BomResult {
+    /** The BOM character if present, empty string otherwise */
+    bom: string;
+    /** The text without the BOM */
+    text: string;
+}
+/** Strip UTF-8 BOM if present */
+export declare function stripBom(content: string): BomResult;
+/** Count leading whitespace characters in a line */
+export declare function countLeadingWhitespace(line: string): number;
+/** Get the leading whitespace string from a line */
+export declare function getLeadingWhitespace(line: string): string;
+/** Compute minimum indentation of non-empty lines */
+export declare function minIndent(text: string): number;
+/** Detect the indentation character used in text (space or tab) */
+export declare function detectIndentChar(text: string): string;
+export declare function convertLeadingTabsToSpaces(text: string, spacesPerTab: number): string;
+export declare function normalizeUnicode(s: string): string;
+/**
+ * Normalize a line for fuzzy comparison.
+ * Trims, collapses whitespace, and normalizes punctuation.
+ */
+export declare function normalizeForFuzzy(line: string): string;
+/**
+ * Adjust newText indentation to match the indentation delta between
+ * what was provided (oldText) and what was actually matched (actualText).
+ *
+ * If oldText has 0 indent but actualText has 12 spaces, we add 12 spaces
+ * to each line in newText.
+ */
+export declare function adjustIndentation(oldText: string, actualText: string, newText: string): string;

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

@@ -0,0 +1,23 @@
+export type NotebookCellType = "code" | "markdown" | "raw";
+export interface NotebookCell {
+    cell_type: NotebookCellType;
+    source?: string | string[];
+    metadata?: Record<string, unknown>;
+    execution_count?: number | null;
+    outputs?: unknown[];
+    [key: string]: unknown;
+}
+export interface NotebookDocument {
+    cells: NotebookCell[];
+    metadata: Record<string, unknown>;
+    nbformat: number;
+    nbformat_minor: number;
+    [key: string]: unknown;
+}
+export declare function isNotebookPath(filePath: string): boolean;
+export declare function splitNotebookSource(content: string): string[];
+export declare function readNotebookDocument(absolutePath: string, displayPath: string): Promise<NotebookDocument>;
+export declare function notebookToEditableText(notebook: NotebookDocument): string;
+export declare function applyNotebookEditableText(notebook: NotebookDocument, text: string, displayPath: string): NotebookDocument;
+export declare function readEditableNotebookText(absolutePath: string, displayPath: string): Promise<string>;
+export declare function serializeEditedNotebookText(absolutePath: string, displayPath: string, text: string): Promise<string>;

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

@@ -0,0 +1,2 @@
+export declare function readEditFileText(absolutePath: string, path: string): Promise<string>;
+export declare function serializeEditFileText(absolutePath: string, path: string, content: string): Promise<string>;

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

@@ -0,0 +1,107 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { FileDiagnosticsResult } from "../lsp";
+import { type Theme } from "../modes/theme/theme";
+import type { OutputMeta } from "../tools/output-meta";
+import { getLspBatchRequest, type LspBatchRequest } from "../tools/render-utils";
+import { type VimRenderArgs } from "../tools/vim";
+import type { EditMode } from "../utils/edit-mode";
+import type { DiffError, DiffResult } from "./diff";
+import type { Operation } from "./modes/patch";
+import type { PerFileDiffPreview } from "./streaming";
+export { getLspBatchRequest, type LspBatchRequest };
+export interface EditToolPerFileResult {
+    path: string;
+    diff: string;
+    firstChangedLine?: number;
+    diagnostics?: FileDiagnosticsResult;
+    op?: Operation;
+    move?: string;
+    isError?: boolean;
+    errorText?: string;
+    /** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+     * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+    displayErrorText?: string;
+    meta?: OutputMeta;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+}
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+    /** Diagnostic result (if available) */
+    diagnostics?: FileDiagnosticsResult;
+    /** Operation type (patch mode only) */
+    op?: Operation;
+    /** New path after move/rename (patch mode only) */
+    move?: string;
+    /** Structured output metadata */
+    meta?: OutputMeta;
+    /** Per-file results (multi-file edits) */
+    perFileResults?: EditToolPerFileResult[];
+    /** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+    path?: string;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+}
+interface EditRenderArgs {
+    path?: string;
+    file_path?: string;
+    oldText?: string;
+    newText?: string;
+    patch?: string;
+    input?: string;
+    all?: boolean;
+    op?: Operation;
+    rename?: string;
+    diff?: string;
+    /**
+     * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
+     */
+    previewDiff?: string;
+    __partialJson?: string;
+    edits?: EditRenderEntry[];
+}
+type EditRenderEntry = {
+    path?: string;
+    rename?: string;
+    move?: string;
+    op?: Operation;
+};
+/** Extended context for edit tool rendering */
+export interface EditRenderContext {
+    /** Edit mode resolved by the caller; lets the renderer dispatch without shape-sniffing */
+    editMode?: EditMode;
+    /** Pre-computed diff preview (computed before tool executes) */
+    editDiffPreview?: DiffResult | DiffError;
+    /** Multi-file streaming diff preview (edits spanning several files) */
+    perFileDiffPreview?: PerFileDiffPreview[];
+    /** Raw in-flight edit text shown while a computed diff preview is unavailable */
+    editStreamingFallback?: string;
+    /** Function to render diff text with syntax highlighting */
+    renderDiff?: (diffText: string, options?: {
+        filePath?: string;
+    }) => string;
+}
+export declare const editToolRenderer: {
+    mergeCallAndResult: boolean;
+    renderCall(args: EditRenderArgs | VimRenderArgs, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: EditToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme, args?: EditRenderArgs): Component;
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Streaming edit preview strategies.
+ *
+ * Each edit mode owns a strategy that knows how to:
+ * - collapse partial-JSON args to the subset safe to preview
+ *   (`extractCompleteEdits`),
+ * - compute unified diff previews for the in-flight args
+ *   (`computeDiffPreview`), and
+ * - render a text placeholder while no diff exists yet
+ *   (`renderStreamingFallback`).
+ *
+ * The shared renderer / `ToolExecutionComponent` consult the strategy via
+ * the injected `editMode` rather than probing argument shape.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
+export interface PerFileDiffPreview {
+    path: string;
+    diff?: string;
+    firstChangedLine?: number;
+    error?: string;
+}
+export interface StreamingDiffContext {
+    cwd: string;
+    signal: AbortSignal;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    hashlineAutoDropPureInsertDuplicates?: boolean;
+}
+export interface EditStreamingStrategy<Args = unknown> {
+    /**
+     * Return the args restricted to edits that are "complete enough" to
+     * compute a diff against. Strategies drop the trailing incomplete entry
+     * when `partialJson` indicates its closing `}` hasn't arrived yet.
+     */
+    extractCompleteEdits(args: Args, partialJson: string | undefined): Args;
+    /**
+     * Compute diff(s) for the given partial args. Returns `null` when args
+     * do not yet carry enough structure to compute anything.
+     */
+    computeDiffPreview(args: Args, ctx: StreamingDiffContext): Promise<PerFileDiffPreview[] | null>;
+    /**
+     * Rendered inline while the diff hasn't been computed yet (or when the
+     * compute returned `null` because args are still too partial).
+     */
+    renderStreamingFallback(args: Args, uiTheme: Theme): string;
+}
+/**
+ * Given an edits array parsed from partial JSON, drop the last entry when the
+ * corresponding object in `partialJson` does not yet end with a closed `}`.
+ *
+ * This guards against `partial-json` silently coercing truncated tails like
+ * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
+ * last entry render a spurious null-write error until the value finishes
+ * streaming.
+ */
+export declare function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[];
+export declare const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>>;
+export { resolveEditMode };

package/dist/types/eval/backend.d.ts

@@ -0,0 +1,40 @@
+import type { ToolSession } from "../tools";
+import type { EvalDisplayOutput, EvalLanguage } from "./types";
+/** Per-cell execute() options. */
+export interface ExecutorBackendExecOptions {
+    cwd: string;
+    sessionId: string;
+    sessionFile: string | undefined;
+    kernelOwnerId: string | undefined;
+    signal?: AbortSignal;
+    session: ToolSession;
+    deadlineMs: number;
+    reset: boolean;
+    artifactPath: string | undefined;
+    artifactId: string | undefined;
+    onChunk: (chunk: string) => void;
+}
+/** Result returned by a backend's execute(). */
+export interface ExecutorBackendResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: EvalDisplayOutput[];
+}
+/** Pluggable language backend for the eval tool. */
+export interface ExecutorBackend {
+    readonly id: EvalLanguage;
+    readonly label: string;
+    /** Source language identifier passed to the syntax highlighter (e.g. "python", "javascript"). */
+    readonly highlightLang: string;
+    /** Cheap availability check. Used by fallback resolution. */
+    isAvailable(session: ToolSession): Promise<boolean>;
+    /** Execute one cell. Caller invokes once per cell and aggregates results. */
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+}

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

@@ -0,0 +1,6 @@
+export * from "./backend";
+export { default as jsBackend } from "./js";
+export * from "./parse";
+export { default as pythonBackend } from "./py";
+export * from "./sniff";
+export * from "./types";

package/dist/types/eval/js/context-manager.d.ts

@@ -0,0 +1,24 @@
+import type { ToolSession } from "../../tools";
+import type { JsDisplayOutput } from "./worker-protocol";
+export { rewriteImports, wrapCode } from "./shared/rewrite-imports";
+export type { JsDisplayOutput } from "./worker-protocol";
+export interface VmRunState {
+    signal?: AbortSignal;
+    onText?: (chunk: string) => void;
+    onDisplay?: (output: JsDisplayOutput) => void;
+}
+export declare function executeInVmContext(options: {
+    sessionKey: string;
+    sessionId: string;
+    cwd: string;
+    session: ToolSession;
+    reset?: boolean;
+    code: string;
+    filename: string;
+    timeoutMs?: number;
+    runState: VmRunState;
+}): Promise<{
+    value: unknown;
+}>;
+export declare function resetVmContext(sessionKey: string): Promise<void>;
+export declare function disposeAllVmContexts(): Promise<void>;

package/dist/types/eval/js/executor.d.ts

@@ -0,0 +1,28 @@
+import type { ToolSession } from "../../tools";
+import { type JsDisplayOutput } from "./context-manager";
+export interface JsExecutorOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    deadlineMs?: number;
+    onChunk?: (chunk: string) => Promise<void> | void;
+    signal?: AbortSignal;
+    sessionId: string;
+    reset?: boolean;
+    sessionFile?: string;
+    artifactPath?: string;
+    artifactId?: string;
+    session: ToolSession;
+}
+export interface JsResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId?: string;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: JsDisplayOutput[];
+}
+export declare function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult>;

package/dist/types/eval/js/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolSession } from "../../tools";
+import type { ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+declare const _default: {
+    id: "js";
+    label: string;
+    highlightLang: string;
+    isAvailable(_session: ToolSession): Promise<boolean>;
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+};
+export default _default;