@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.1

package/lib/types/tools/omp/tools/tool-timeouts.d.ts

@@ -0,0 +1,57 @@
+export interface ToolTimeoutConfig {
+    /** Default timeout in seconds when agent omits the field */
+    default: number;
+    /** Minimum allowed timeout in seconds */
+    min: number;
+    /** Maximum allowed timeout in seconds (per-tool ceiling) */
+    max: number;
+}
+export declare const TOOL_TIMEOUTS: {
+    readonly bash: {
+        readonly default: 300;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly eval: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly browser: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 300;
+    };
+    readonly computer: {
+        readonly default: 120;
+        readonly min: 1;
+        readonly max: 300;
+    };
+    readonly ssh: {
+        readonly default: 60;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly fetch: {
+        readonly default: 20;
+        readonly min: 1;
+        readonly max: 45;
+    };
+    readonly debug: {
+        readonly default: 30;
+        readonly min: 5;
+        readonly max: 300;
+    };
+};
+export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;
+/**
+ * Clamp a raw timeout to the allowed range for a tool.
+ *
+ * When `rawTimeout` is undefined the tool's `default` is used. A positive
+ * `maxTimeout` (the `tools.maxTimeout` global ceiling) caps the *resolved*
+ * value — including the default-fallback path — before the per-tool `min`/`max`
+ * floor and ceiling apply, so a configured global cap governs calls where the
+ * agent omits `timeout`, not only explicitly-passed values. `maxTimeout <= 0`
+ * means no global cap.
+ */
+export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number, maxTimeout?: number): number;

package/lib/types/tools/omp/tools/write.d.ts

@@ -0,0 +1,53 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../../omp/sdk.ts";
+import type { OutputMeta } from "../../omp/tools/output-meta.ts";
+import { type XdevDispatch } from "../../omp/tools/resolve.ts";
+declare const writeSchema: import("@oh-my-pi/omptype").FluentType<{
+    path: string;
+    content: string;
+}, {
+    path: string;
+    content: string;
+}>;
+export type WriteToolInput = typeof writeSchema.infer;
+/** Details returned by the write tool for TUI rendering */
+export interface WriteToolDetails {
+    meta?: OutputMeta;
+    /** Set when the file was auto-chmod'd because content begins with a `#!` shebang. */
+    madeExecutable?: boolean;
+    /** Absolute filesystem path the write resolved to. Used by the renderer to wrap
+     * the (possibly cwd-relative) header path in an OSC 8 `file://` hyperlink. */
+    resolvedPath?: string;
+    /** Set when the write dispatched an `xd://` tool device; drives renderer delegation. */
+    xdev?: XdevDispatch;
+}
+type WriteParams = WriteToolInput;
+/**
+ * Write tool implementation.
+ *
+ * Creates or overwrites files with optional LSP formatting and diagnostics.
+ */
+export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "write";
+    readonly approval: (args: unknown) => ToolApprovalDecision;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly label = "Write";
+    readonly description: string;
+    readonly parameters: import("@oh-my-pi/omptype").FluentType<{
+        path: string;
+        content: string;
+    }, {
+        path: string;
+        content: string;
+    }>;
+    readonly strict = true;
+    readonly concurrency = "exclusive";
+    readonly loadMode = "essential";
+    /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
+    matcherDigest(args: unknown): string | undefined;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, { path: rawPath, content }: WriteParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
+}
+export {};

package/lib/types/tools/omp/tools/writethrough.d.ts

@@ -0,0 +1,24 @@
+/**
+ * File-write channel for the write/edit engines.
+ *
+ * OMP routes every edit/write through an LSP writethrough (format +
+ * diagnostics). DSH has no LSP infrastructure (plan.md 拍板#5 cuts LSP), so
+ * the channel performs the actual file write directly: the edit itself is
+ * fully functional; formatting/diagnostics simply do not exist as a DSH
+ * capability. LSP-only parameters (batch request, deferred-diagnostics
+ * handle) are not part of the DSH signature.
+ */
+/**
+ * Callback type for the file write channel. DSH's writethrough writes the
+ * content to `dst` (via the provided file handle when present) and returns
+ * nothing.
+ */
+export type WritethroughCallback = (dst: string, content: string, signal?: AbortSignal, file?: {
+    write(content: string): Promise<void>;
+}) => Promise<void>;
+/** Write `content` to `dst` (or the passed file handle) — no LSP pass. */
+export declare function writethroughNoop(dst: string, content: string, _signal?: AbortSignal, file?: {
+    write(content: string): Promise<void>;
+}): Promise<void>;
+/** Async UTF-8 write (node:fs) used when no file handle is supplied. */
+export declare function writeFileUtf8(dst: string, content: string): Promise<void>;

package/lib/types/tools/omp/utils/block-context.d.ts

@@ -0,0 +1,35 @@
+export interface LineSpan {
+    startLine: number;
+    endLine: number;
+}
+/** Where the source came from, so tree-sitter can pick a grammar. */
+export interface BlockContextSource {
+    path?: string;
+    lang?: string;
+}
+export type LineEntry = {
+    kind: "line";
+    lineNumber: number;
+    text: string;
+    context: boolean;
+} | {
+    kind: "ellipsis";
+};
+/**
+ * Resolve the off-window boundary lines for a visible window: tree-sitter
+ * syntactic spans first (covers brace and indentation languages), falling back
+ * to a lexical bracket scan when the grammar is unavailable. Returns a map of
+ * `lineNumber → source text` for the lines to surface, never including a line
+ * already visible.
+ */
+export declare function findBlockContextLines(fullLines: readonly string[], visibleInput: ReadonlySet<number> | readonly number[], source?: BlockContextSource): Map<number, string>;
+/**
+ * Build display entries for `visibleSpans` plus any off-window block-boundary
+ * lines, in source order, with `{ kind: "ellipsis" }` markers inserted across
+ * non-contiguous gaps. `options.lineText` lets callers substitute display text
+ * (e.g. column-truncated lines) for a given line number.
+ */
+export declare function buildLineEntriesWithBlockContext(fullLines: readonly string[], visibleSpans: readonly LineSpan[], source?: BlockContextSource, options?: {
+    lineText?: (lineNumber: number, sourceText: string, context: boolean) => string;
+}): LineEntry[];
+export declare function lineEntriesToPlainText(entries: readonly LineEntry[], ellipsis?: string): string;

package/lib/types/tools/omp/utils/cpuprofile.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Parser and renderer for V8 `.cpuprofile` files (emitted by `node --cpu-prof`,
+ * `bun --cpu-prof`, Chrome DevTools, and the CDP `Profiler` domain).
+ *
+ * The raw file is a JSON blob with a flat node table and up to millions of
+ * sample/timestamp entries — useless to read directly. `renderCpuProfile`
+ * converts it into a compact bottleneck summary:
+ *
+ * - the hot-path call tree, pruned to frames with meaningful self time,
+ *   with pass-through chains collapsed and direct recursion flattened
+ * - `(idle)` time excluded from on-CPU totals
+ * - a profile-wide "top functions by self time" table
+ *
+ * Consumed by the read tool: `*.cpuprofile` reads show the summary, `:raw`
+ * returns the original JSON.
+ */
+/** Matches paths the read tool should treat as V8 CPU profiles. */
+export declare function isCpuProfilePath(filePath: string): boolean;
+/** Call-site metadata of one profile node. `lineNumber` is 0-based. */
+export interface CpuProfileCallFrame {
+    functionName: string;
+    url?: string;
+    lineNumber?: number;
+}
+/** One node in the flat profile tree; `children` are node ids. */
+export interface CpuProfileNode {
+    id: number;
+    callFrame: CpuProfileCallFrame;
+    hitCount?: number;
+    children?: number[];
+}
+/** Parsed V8 CPU profile. `startTime`/`endTime`/`timeDeltas` are microseconds. */
+export interface CpuProfile {
+    nodes: CpuProfileNode[];
+    startTime: number;
+    endTime: number;
+    samples?: number[];
+    timeDeltas?: number[];
+}
+/**
+ * Parse a `.cpuprofile` JSON blob. Accepts both the bare profile and the CDP
+ * `Profiler.stop` result shape (`{ profile: {...} }`). Returns null when the
+ * text is not a structurally valid V8 CPU profile.
+ */
+export declare function parseCpuProfile(text: string): CpuProfile | null;
+/**
+ * Render a V8 CPU profile as an agent-friendly bottleneck summary.
+ * Returns null when `text` is not a CPU profile (caller falls back to the
+ * plain-text path).
+ */
+export declare function renderCpuProfile(text: string): string | null;

package/lib/types/tools/omp/utils/edit-mode.d.ts

@@ -0,0 +1,13 @@
+export type EditMode = "replace" | "patch" | "hashline" | "apply_patch";
+export declare const DEFAULT_EDIT_MODE: EditMode;
+export declare const EDIT_MODES: EditMode[];
+export declare function normalizeEditMode(mode?: string | null): EditMode | undefined;
+export interface EditModeSettingsLike {
+    get(key: "edit.mode"): unknown;
+    getEditVariantForModel?(model: string | undefined): EditMode | null;
+}
+export interface EditModeSessionLike {
+    settings: EditModeSettingsLike;
+    getActiveModelString?: () => string | undefined;
+}
+export declare function resolveEditMode(session: EditModeSessionLike): EditMode;

package/lib/types/tools/omp/utils/file-display-mode.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Resolve line-display mode for file-like outputs (read, grep, @file mentions).
+ */
+export interface FileDisplayMode {
+    lineNumbers: boolean;
+    hashLines: boolean;
+}
+/** Session-like object providing settings and tool availability for display mode resolution. */
+export interface FileDisplayModeSession {
+    /** Whether the edit tool is available. Hashlines are suppressed without it. */
+    hasEditTool?: boolean;
+    settings: {
+        get(key: "readLineNumbers" | "edit.mode"): unknown;
+    };
+}
+/**
+ * Computes effective line display mode from session settings/env.
+ * Hashline mode takes precedence and implies line-addressed output everywhere.
+ * Hashlines are suppressed when the edit tool is not available (e.g. scout agents),
+ * when the caller signals a `raw` read, and when the source is `immutable`
+ * (e.g. internal URLs like artifact://, agent://, memory:// — there is no edit
+ * path that could consume the anchors). Raw output is returned as-is.
+ */
+export declare function resolveFileDisplayMode(session: FileDisplayModeSession, options?: {
+    raw?: boolean;
+    immutable?: boolean;
+}): FileDisplayMode;

package/lib/types/tools/omp/utils/image-loading.d.ts

@@ -0,0 +1,51 @@
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import { type ImageResizeOptions } from "./image-resize";
+/**
+ * Ollama and its local-backend family decode image input through llama.cpp /
+ * `stb_image`, which is compiled without WebP support, so a WebP upload fails
+ * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
+ * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
+ */
+export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined): boolean;
+/**
+ * `true` when `model` cannot decode WebP, otherwise `undefined` so the
+ * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight
+ * into {@link ImageResizeOptions.excludeWebP}.
+ */
+export declare function webpExclusionForModel(model: Pick<Model, "provider" | "api"> | undefined): true | undefined;
+export declare const MAX_IMAGE_INPUT_BYTES: number;
+export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
+export interface LoadImageInputOptions {
+    path: string;
+    cwd: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    resolvedPath?: string;
+    detectedMimeType?: string;
+    /** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
+    excludeWebP?: boolean;
+    /**
+     * DSH extension (拍板#22 config expansion): resize-knob passthrough onto
+     * {@link resizeImage}. Upstream never passes these — it relies on the
+     * hardcoded 1568px/500KB/200px/quality-80 defaults; the tool-plus config
+     * panel wires user-tunable values through here. Unset = upstream behavior.
+     */
+    resize?: ImageResizeOptions;
+}
+export interface LoadedImageInput {
+    resolvedPath: string;
+    mimeType: string;
+    data: string;
+    textNote: string;
+    dimensionNote?: string;
+    bytes: number;
+}
+export declare class ImageInputTooLargeError extends Error {
+    readonly bytes: number;
+    readonly maxBytes: number;
+    constructor(bytes: number, maxBytes: number);
+}
+/** Converts an image to PNG, rejecting when the runtime cannot decode or encode it. */
+export declare function convertImageToPng(image: ImageContent): Promise<ImageContent>;
+export declare function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null>;
+export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;

package/lib/types/tools/omp/utils/image-resize.d.ts

@@ -0,0 +1,42 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export interface ImageResizeOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    /** Smallest allowed edge length (px). Inputs below this are scaled up. */
+    minDimension?: number;
+    maxBytes?: number;
+    jpegQuality?: number;
+    excludeWebP?: boolean;
+}
+export interface ResizedImage {
+    buffer: Uint8Array;
+    mimeType: string;
+    originalWidth: number;
+    originalHeight: number;
+    width: number;
+    height: number;
+    wasResized: boolean;
+    decodeFailed?: boolean;
+    get data(): string;
+}
+/**
+ * Resize and recompress an image to fit within the specified max dimensions and file size.
+ *
+ * Strategy:
+ *  1. Probe metadata. If already within all limits, return original.
+ *  2. Resize to fit max dimensions and encode at high quality across PNG/JPEG (+ WebP) — return smallest.
+ *  3. If still too large, walk a lossy JPEG/WebP quality ladder.
+ *  4. If still too large, walk a dimension-scale ladder × quality ladder.
+ *  5. If still too large, return the smallest variant produced.
+ *
+ * Set OMP_NO_WEBP to exclude WebP from encoding (llama.cpp STB doesn't decode it).
+ *
+ * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
+ * off the JS thread when the terminal (`.bytes()`) is awaited.
+ */
+export declare function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage>;
+/**
+ * Format a dimension note for resized images.
+ * This helps the model understand the coordinate mapping.
+ */
+export declare function formatDimensionNote(result: ResizedImage): string | undefined;

package/lib/types/tools/omp/utils/lang-from-path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Language id for syntax highlighting and UI (icons, read tool), or undefined if unknown.
+ */
+export declare function getLanguageFromPath(filePath: string): string | undefined;
+export declare function isMarkdownPath(filePath: string): boolean;
+/**
+ * LSP language identifier; falls back to `plaintext`.
+ */
+export declare function detectLanguageId(filePath: string): string;

package/lib/types/tools/omp/utils/markit-cache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cache schema/format revision. Bumping it changes the on-disk key prefix
+ * (`v<N>-...`), so old entries become unreachable and are pruned naturally.
+ * Bump when the cache *file* shape changes (entry JSON layout, key scheme).
+ *
+ * Converter *output* changes are handled separately: the package version is
+ * folded into the key (see {@link markitConversionCacheKey}), so any release
+ * that ships new markdown from `src/markit/converters/*` auto-invalidates the
+ * cache without a manual bump here.
+ */
+export declare const MARKIT_CONVERSION_CACHE_VERSION = 1;
+export declare const MAX_MARKIT_CONVERSION_CACHE_BYTES: number;
+export type MarkitConversionCacheStatus = "hit" | "miss" | "skipped";
+export type MarkitConversionCacheReadResult = {
+    status: "hit";
+    content: string;
+} | {
+    status: "miss";
+};
+export declare function markitConversionCacheKey(bytes: Uint8Array, extension: string): string;
+export declare function readMarkitConversionCache(key: string): Promise<MarkitConversionCacheReadResult>;
+export declare function pruneMarkitConversionCache(cacheDir: string): Promise<void>;
+export declare function writeMarkitConversionCache(key: string, content: string): Promise<void>;

package/lib/types/tools/omp/utils/markit.d.ts

@@ -0,0 +1,30 @@
+import { type MarkitConversionCacheStatus } from "./markit-cache";
+/**
+ * File extensions markit can actually convert to markdown — one per registered
+ * converter in `src/markit/registry.ts` (pdf, docx, pptx, xlsx, epub). This is
+ * the single source of truth shared by the read, fetch, and CLI file tools so
+ * the advertised set never drifts from the converters that back it. Legacy
+ * binary formats (`.doc`, `.ppt`, `.xls`, `.rtf`) are intentionally absent:
+ * markit has no converter for them, so routing them here only produced an
+ * `Unsupported format` error instead of letting them fall through to the
+ * binary-file handling.
+ */
+export declare const CONVERTIBLE_EXTENSIONS: ReadonlySet<string>;
+export interface MarkitConversionResult {
+    content: string;
+    ok: boolean;
+    error?: string;
+    cache?: MarkitConversionCacheStatus;
+}
+export interface MarkitFileConversionOptions {
+    /**
+     * Directory converters may use for extracted image or diagram files. Since
+     * those files are conversion side effects, conversions using this option
+     * bypass the markdown cache.
+     */
+    imageDir?: string;
+}
+export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal, options?: MarkitFileConversionOptions): Promise<MarkitConversionResult>;
+export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal, options?: {
+    useCache?: boolean;
+}): Promise<MarkitConversionResult>;

package/lib/types/tools/omp/utils/profile-tree.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared display-tree machinery for profile summaries (macOS `sample` reports,
+ * V8 `.cpuprofile` files). Callers build {@link ProfileNode} trees with a
+ * domain-specific metric (on-CPU samples, self microseconds, …); this module
+ * merges same-key siblings, flattens direct recursion, collapses pass-through
+ * chains, and renders the pruned hot-path tree.
+ */
+/** Display node: merged, recursion-flattened mirror of a profile subtree. */
+export interface ProfileNode {
+    /** Merge/recursion identity (demangled symbol, function@call-site, …). */
+    key: string;
+    /** Human-readable label; recursion and truncation decorations are applied at render time. */
+    label: string;
+    /** Inclusive metric for this subtree (on-CPU samples, self µs, …); drives pruning and display. */
+    value: number;
+    /** Levels of direct recursion flattened into this node. */
+    recursion: number;
+    children: ProfileNode[];
+}
+/** Merge `b` into `a` (same key), combining values and child lists. */
+export declare function mergeInto(a: ProfileNode, b: ProfileNode): void;
+/**
+ * Flatten direct recursion: children carrying the node's own key are dissolved
+ * into it (their children promoted and merged), so a 15-deep recursive spine
+ * renders as one annotated node.
+ */
+export declare function flattenRecursion(node: ProfileNode): void;
+/** `n` as a percentage of `total`, one decimal (`"12.3%"`); `"0%"` when total is empty. */
+export declare function formatPct(n: number, total: number): string;
+/** Options for {@link renderProfileNode}. */
+export interface RenderTreeContext {
+    out: string[];
+    /** Denominator for percentage annotations. */
+    total: number;
+    /** Minimum subtree value a child needs to stay visible. */
+    minValue: number;
+    /** Format a metric value for the left column. */
+    formatValue: (value: number) => string;
+    /** Left-column width (characters) for formatted values. */
+    valueWidth: number;
+}
+/**
+ * Render one hot-path subtree: pass-through chains (single kept child, no own
+ * contribution above `minValue`) collapse into a single `a › b › c` line, and
+ * children below `minValue` are pruned.
+ */
+export declare function renderProfileNode(node: ProfileNode, indent: number, ctx: RenderTreeContext): void;

package/lib/types/tools/omp/utils/sample-profile.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Parser and renderer for macOS `/usr/bin/sample` call-tree reports
+ * (conventionally saved as `*.sample.txt`).
+ *
+ * The raw report is a 10k+ line ASCII call tree with mangled symbols —
+ * expensive for an agent to digest. `renderSampleProfile` converts it into a
+ * compact bottleneck summary:
+ *
+ * - per-thread hot paths, pruned to frames with meaningful on-CPU samples,
+ *   with pass-through chains collapsed and direct recursion flattened
+ * - blocked/idle threads reduced to a one-line classification
+ * - a process-wide "top functions by self samples" table
+ * - Rust v0 and legacy symbols demangled (best-effort, path extraction)
+ *
+ * Consumed by the read tool: `*.sample.txt` reads show the summary, `:raw`
+ * returns the original bytes.
+ */
+/** Matches paths the read tool should treat as macOS sample reports. */
+export declare function isSampleProfilePath(filePath: string): boolean;
+/** One frame in the sampled call tree. Counts are sample hits (subtree total). */
+export interface SampleFrame {
+    count: number;
+    symbol: string;
+    module?: string;
+    children: SampleFrame[];
+}
+/** One sampled thread: `Thread_<id>` root plus its call tree. */
+export interface SampleThread {
+    id: string;
+    name?: string;
+    total: number;
+    roots: SampleFrame[];
+}
+/** Metadata from the report preamble (everything before `Call graph:`). */
+export interface SampleProfileHeader {
+    process: string;
+    pid: number;
+    intervalMs: number;
+    path?: string;
+    codeType?: string;
+    osVersion?: string;
+    footprint?: string;
+    footprintPeak?: string;
+}
+/** Parsed macOS sample report. */
+export interface SampleProfile {
+    header: SampleProfileHeader;
+    threads: SampleThread[];
+}
+/**
+ * Parse a macOS `sample` report. Returns null when the text does not look
+ * like sample output (missing analysis preamble or `Call graph:` section).
+ */
+export declare function parseSampleProfile(text: string): SampleProfile | null;
+/**
+ * Best-effort demangle of Rust symbols (v0 `_R…` and legacy `_ZN…E`).
+ * For v0 this is a path extractor, not a full demangler: identifiers are
+ * pulled out in order and joined with `::`, so generic arguments appear as
+ * extra path segments. Non-Rust symbols pass through unchanged.
+ */
+export declare function demangleSymbol(raw: string): string;
+/**
+ * Render a macOS sample report as an agent-friendly bottleneck summary.
+ * Returns null when `text` is not sample output (caller falls back to the
+ * plain-text path).
+ */
+export declare function renderSampleProfile(text: string): string | null;

package/lib/types/tools/omp/utils/sixel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns whether SIXEL passthrough is explicitly enabled.
+ *
+ * Both gates must be enabled to preserve SIXEL control sequences:
+ * - PI_FORCE_IMAGE_PROTOCOL=sixel
+ * - PI_ALLOW_SIXEL_PASSTHROUGH=1
+ */
+export declare function isSixelPassthroughEnabled(): boolean;
+/** Returns true when the text contains a SIXEL start sequence. */
+export declare function containsSixelSequence(text: string): boolean;
+/**
+ * Returns a boolean mask indicating which lines belong to a SIXEL sequence block.
+ * Supports multi-line SIXEL payloads generated by libsixel.
+ */
+export declare function getSixelLineMask(lines: string[]): boolean[];
+/** Returns true when the line contains a SIXEL start sequence. */
+export declare function isSixelLine(line: string): boolean;
+/**
+ * Sanitizes text while preserving embedded SIXEL sequences when passthrough is enabled.
+ */
+export declare function sanitizeWithOptionalSixelPassthrough(text: string, sanitize: (text: string) => string): string;

package/lib/types/tools/omp/utils/tools-manager.d.ts

@@ -0,0 +1,11 @@
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
+export declare function getToolPath(tool: ToolName): string | null;
+/** Download a tool asset without handing the streaming Response to Bun.write. */
+export declare function downloadFile(url: string, dest: string, signal?: AbortSignal): Promise<void>;
+type EnsureToolOptions = {
+    signal?: AbortSignal;
+    silent?: boolean;
+    notify?: (message: string) => void;
+};
+export declare function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOptions): Promise<string | undefined>;
+export {};

package/lib/types/tools/omp/utils/turndown.d.ts

@@ -0,0 +1,15 @@
+import TurndownService from "@oh-my-pi/pi-utils/turndown";
+/**
+ * Build a Turndown instance configured for GFM with the fixes omp relies on:
+ * `~~strikethrough~~`, unescaped heading periods, and single-space list markers.
+ *
+ * Shared by the web scrapers (HTML → markdown) and the markit document engine
+ * (`src/markit`). The rule set must stay identical across both call sites.
+ */
+export declare function createTurndown(): TurndownService;
+/**
+ * Normalize HTML tables so turndown-plugin-gfm can render them:
+ * - strip `<p>` tags inside `<td>`/`<th>` cells (joining paragraphs with a space)
+ * - wrap the first row in `<thead>` when missing
+ */
+export declare function normalizeTablesHtml(html: string): string;