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

package/dist/types/tools/output-meta.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Structured metadata for tool outputs.
+ *
+ * Tools populate details.meta using the fluent OutputMetaBuilder.
+ * The tool wrapper automatically formats and appends notices at message boundary.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { type Settings } from "../config/settings";
+import type { Theme } from "../modes/theme/theme";
+import { type OutputSummary, type TruncationResult } from "../session/streaming-output";
+/**
+ * Truncation metadata for the output notice.
+ */
+export interface TruncationMeta {
+    direction: "head" | "tail" | "middle";
+    truncatedBy: "lines" | "bytes" | "middle";
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    maxBytes?: number;
+    /** Line range shown (1-indexed, inclusive). Omitted for middle elision. */
+    shownRange?: {
+        start: number;
+        end: number;
+    };
+    /** Head/tail line ranges shown when direction === "middle". */
+    headRange?: {
+        start: number;
+        end: number;
+    };
+    tailRange?: {
+        start: number;
+        end: number;
+    };
+    /** Bytes elided from the middle. */
+    elidedBytes?: number;
+    /** Lines elided from the middle. */
+    elidedLines?: number;
+    /** Artifact ID if full output was saved */
+    artifactId?: string;
+    /** Next offset for pagination (head truncation only) */
+    nextOffset?: number;
+}
+/**
+ * Source resolution info for the output.
+ */
+export type SourceMeta = {
+    type: "path";
+    value: string;
+} | {
+    type: "url";
+    value: string;
+} | {
+    type: "internal";
+    value: string;
+};
+/**
+ * LSP diagnostic info (for edit/write tools).
+ */
+export interface DiagnosticMeta {
+    summary: string;
+    messages: string[];
+}
+/**
+ * Limit-specific notices.
+ */
+export interface LimitsMeta {
+    matchLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    resultLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    headLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    columnTruncated?: {
+        maxColumn: number;
+    };
+}
+/**
+ * Structured metadata for tool outputs.
+ */
+export interface OutputMeta {
+    truncation?: TruncationMeta;
+    source?: SourceMeta;
+    diagnostics?: DiagnosticMeta;
+    limits?: LimitsMeta;
+}
+export interface TruncationOptions {
+    direction: "head" | "tail" | "middle";
+    startLine?: number;
+    totalFileLines?: number;
+    artifactId?: string;
+}
+export interface TruncationSummaryOptions {
+    direction: "head" | "tail" | "middle";
+    startLine?: number;
+    totalFileLines?: number;
+}
+export interface TruncationTextOptions {
+    direction: "head" | "tail" | "middle";
+    totalLines?: number;
+    totalBytes?: number;
+    maxBytes?: number;
+}
+/**
+ * Fluent builder for OutputMeta.
+ *
+ * @example
+ * ```ts
+ * details.meta = outputMeta()
+ *   .truncation(truncation, { direction: "head" })
+ *   .matchLimit(limitReached ? effectiveLimit : 0)
+ *   .columnTruncated(linesTruncated ? DEFAULT_MAX_COLUMN : 0)
+ *   .get();
+ * ```
+ */
+export declare class OutputMetaBuilder {
+    #private;
+    /** Add truncation info from TruncationResult. No-op if not truncated. */
+    truncation(result: TruncationResult, options: TruncationOptions): this;
+    /** Add truncation info from OutputSummary. No-op if not truncated. */
+    truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
+    /** Add truncation info from truncated output text. No-op if truncation not detected. */
+    truncationFromText(text: string, options: TruncationTextOptions): this;
+    /** Add match limit notice. No-op if reached <= 0. */
+    matchLimit(reached: number, suggestion?: number): this;
+    /** Add limit notices in one call. */
+    limits(limits: {
+        matchLimit?: number;
+        resultLimit?: number;
+        headLimit?: number;
+        columnMax?: number;
+    }): this;
+    /** Add result limit notice. No-op if reached <= 0. */
+    resultLimit(reached: number, suggestion?: number): this;
+    /** Add limit notice for head truncation. No-op if reached <= 0. */
+    headLimit(reached: number, suggestion?: number): this;
+    /** Add column truncation notice. No-op if maxColumn <= 0. */
+    columnTruncated(maxColumn: number): this;
+    /** Add source path info. */
+    sourcePath(value: string): this;
+    /** Add source URL info. */
+    sourceUrl(value: string): this;
+    /** Add internal URL source info (skill://, agent://, artifact://). */
+    sourceInternal(value: string): this;
+    /** Add LSP diagnostics. No-op if no messages. */
+    diagnostics(summary: string, messages: string[]): this;
+    /** Get the built OutputMeta, or undefined if empty. */
+    get(): OutputMeta | undefined;
+}
+/** Create a new OutputMetaBuilder. */
+export declare function outputMeta(): OutputMetaBuilder;
+export declare function formatFullOutputReference(artifactId: string): string;
+export declare function formatTruncationMetaNotice(truncation: TruncationMeta): string;
+/**
+ * Format styled artifact reference with warning color and brackets.
+ * For TUI rendering of truncation warnings.
+ */
+export declare function formatStyledArtifactReference(artifactId: string, theme: Theme): string;
+/**
+ * Format notices from OutputMeta for LLM consumption.
+ * Returns empty string if no notices needed.
+ */
+export declare function formatOutputNotice(meta: OutputMeta | undefined): string;
+/**
+ * Format a styled truncation warning message.
+ * Returns null if no truncation metadata present.
+ */
+export declare function formatStyledTruncationWarning(meta: OutputMeta | undefined, theme: Theme): string | null;
+/**
+ * Strip the trailing notice that {@link appendOutputNotice} bakes into the
+ * LLM-facing content body. Renderers should call this before printing
+ * `result.content` text in the TUI, because they emit a styled warning line of
+ * their own; without this, users see the same `[Showing lines …]` string twice
+ * (once verbatim from the body, once as the styled `⟨…⟩` warning).
+ *
+ * Safe to call eagerly: returns the input unchanged when no notice is present
+ * (e.g. during streaming, before {@link wrappedExecute} runs).
+ */
+export declare function stripOutputNotice(text: string, meta: OutputMeta | undefined): string;
+/**
+ * Resolve the OutputSink `headBytes` budget from session settings.
+ * Exposed so streaming executors (bash/python/ssh/eval) can opt into
+ * middle elision with the same per-user configuration.
+ */
+export declare function resolveOutputSinkHeadBytes(s: Settings | undefined): number;
+/**
+ * Resolve the per-line column cap from session settings. Shared by streaming
+ * executors (bash/python/ssh/eval via OutputSink) and the `read` tool's
+ * line-buffer post-processing, so one setting controls both surfaces.
+ */
+export declare function resolveOutputMaxColumns(s: Settings | undefined): number;
+/**
+ * Wrap a tool to:
+ * 1. Automatically append output notices based on details.meta
+ * 2. Handle ToolError rendering
+ */
+export declare function wrapToolWithMetaNotice<T extends AgentTool<any, any, any>>(tool: T): T;

package/dist/types/tools/path-utils.d.ts

@@ -0,0 +1,125 @@
+export declare function expandTilde(filePath: string, home?: string): string;
+export declare function expandPath(filePath: string): string;
+export declare function splitPathAndSel(rawPath: string): {
+    path: string;
+    sel?: string;
+};
+export declare function normalizeLocalScheme(filePath: string): string;
+export declare function isInternalUrlPath(filePath: string): boolean;
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ *
+ * A bare root slash is treated as a workspace-root alias for tool inputs. Users
+ * often pass `/` to mean “search from here”, and letting tools escape to the
+ * filesystem root is almost never what they intended.
+ */
+export declare function resolveToCwd(filePath: string, cwd: string): string;
+export declare function formatPathRelativeToCwd(filePath: string, cwd: string, options?: {
+    trailingSlash?: boolean;
+}): string;
+/**
+ * Strip matching surrounding double quotes from a path string.
+ * Common when users paste quoted paths from Windows Explorer or shell copy-paste.
+ * Only double quotes — single quotes are valid POSIX filename characters.
+ * Tradeoff: a POSIX path literally starting AND ending with " would also be unquoted.
+ * Accepted because such names are virtually nonexistent in practice.
+ */
+export declare function stripOuterDoubleQuotes(input: string): string;
+export declare function normalizePathLikeInput(input: string): string;
+export declare function hasGlobPathChars(filePath: string): boolean;
+export interface ParsedSearchPath {
+    basePath: string;
+    glob?: string;
+}
+export interface ParsedFindPattern {
+    basePath: string;
+    globPattern: string;
+    hasGlob: boolean;
+}
+export interface ResolvedSearchTarget {
+    basePath: string;
+    glob?: string;
+}
+export interface ResolvedMultiSearchPath {
+    basePath: string;
+    glob?: string;
+    scopePath: string;
+    exactFilePaths?: string[];
+    targets?: ResolvedSearchTarget[];
+}
+export interface ResolvedMultiFindPattern {
+    basePath: string;
+    globPattern: string;
+    scopePath: string;
+}
+/**
+ * Split a user path into a base path + glob pattern for tools that delegate to
+ * APIs accepting separate `path` and `glob` arguments.
+ */
+export declare function parseSearchPath(filePath: string): ParsedSearchPath;
+export declare function parseFindPattern(pattern: string): ParsedFindPattern;
+export declare function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): string | undefined;
+export declare function resolveExplicitSearchPaths(pathItems: string[], cwd: string, suffixGlob?: string): Promise<ResolvedMultiSearchPath | undefined>;
+export declare function resolveExplicitFindPatterns(patternItems: string[], cwd: string): Promise<ResolvedMultiFindPattern | undefined>;
+/**
+ * Result of partitioning a list of user-supplied paths/globs into entries whose
+ * base directory currently exists on disk versus those that do not.
+ *
+ * Used by multi-path tools (search, find, ast_grep, ast_edit) to tolerate one
+ * or more missing entries in a multi-path call: the surviving entries should
+ * still be searched, with the missing entries surfaced as a non-fatal warning.
+ */
+export interface PartitionedPaths {
+    /** Raw input strings whose resolved base path exists. */
+    valid: string[];
+    /** Raw input strings whose resolved base path is missing (ENOENT). */
+    missing: string[];
+}
+/**
+ * Stat each input's base path concurrently; return entries split by existence.
+ *
+ * `splitter` is expected to be {@link parseFindPattern} or
+ * {@link parseSearchPath}: both return a `basePath` field that this helper
+ * resolves against `cwd` and stats. ENOENT is the only swallowed error — every
+ * other stat failure (permission, IO, etc.) propagates so callers do not silently
+ * skip paths that exist but are unreadable.
+ *
+ * Order of `valid` and `missing` follows the input order, so callers can rely
+ * on `valid[0]` matching the first surviving user-supplied entry.
+ */
+export declare function partitionExistingPaths(items: string[], cwd: string, splitter: (item: string) => {
+    basePath: string;
+}): Promise<PartitionedPaths>;
+export declare function resolveReadPath(filePath: string, cwd: string): string;
+export interface ToolScopeOptions {
+    rawPaths: string[];
+    cwd: string;
+    /** Verb used in the "Cannot {action} internal URL without a backing file: …" message. */
+    internalUrlAction: string;
+    /** Collect absolute paths flagged immutable by their internal-URL handler. */
+    trackImmutableSources?: boolean;
+    /** Honor `exactFilePaths` from {@link resolveExplicitSearchPaths} (search-only). */
+    surfaceExactFilePaths?: boolean;
+    /** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
+    multipathStatHint?: string;
+}
+export interface ToolScopeResolution {
+    searchPath: string;
+    scopePath: string;
+    globFilter: string | undefined;
+    isDirectory: boolean;
+    multiTargets?: ResolvedSearchTarget[];
+    exactFilePaths?: string[];
+    missingPaths: string[];
+    immutableSourcePaths: Set<string>;
+}
+/**
+ * Shared path-input pipeline for `search`, `ast_grep`, and `ast_edit`:
+ *  1. normalize + reject empty paths,
+ *  2. resolve internal URLs through {@link InternalUrlRouter} to backing files,
+ *  3. partition existing vs missing when multiple paths are supplied,
+ *  4. derive a single search base path / glob, or a multi-target list,
+ *  5. stat the resolved base path so callers can branch on directory vs file scope.
+ */
+export declare function resolveToolSearchScope(opts: ToolScopeOptions): Promise<ToolScopeResolution>;

package/dist/types/tools/plan-mode-guard.d.ts

@@ -0,0 +1,18 @@
+import type { ToolSession } from ".";
+/**
+ * Resolve a write/edit target to its absolute filesystem path.
+ *
+ * In plan mode, transparently redirects targets whose basename matches the
+ * plan file's basename (e.g. a bare `PLAN.md` or `./PLAN.md`) to the canonical
+ * plan file location at `state.planFilePath`. This lets `write` and `edit`
+ * accept the unqualified plan filename and have the change land at the
+ * session-scoped `local://PLAN.md` artifact instead of a stray cwd-relative
+ * file the plan-mode guard would otherwise reject.
+ *
+ * Outside plan mode (or when the basename does not match) this is a no-op.
+ */
+export declare function resolvePlanPath(session: ToolSession, targetPath: string): string;
+export declare function enforcePlanModeWrite(session: ToolSession, targetPath: string, options?: {
+    move?: string;
+    op?: "create" | "update" | "delete";
+}): void;

package/dist/types/tools/read.d.ts

@@ -0,0 +1,85 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import { type TruncationResult } from "../session/streaming-output";
+import { type OutputMeta } from "./output-meta";
+declare const readSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+export type ReadToolInput = z.infer<typeof readSchema>;
+export interface ReadToolDetails {
+    kind?: "file" | "url";
+    truncation?: TruncationResult;
+    isDirectory?: boolean;
+    resolvedPath?: string;
+    suffixResolution?: {
+        from: string;
+        to: string;
+    };
+    url?: string;
+    finalUrl?: string;
+    contentType?: string;
+    method?: string;
+    notes?: string[];
+    meta?: OutputMeta;
+    /** Raw text + start line for user-visible TUI rendering, set when content is text-like.
+     * Mirrors the same lines the model receives but without hashline/line-number prefixes,
+     * so the TUI can render the file content with its own gutter without re-parsing the formatted text. */
+    displayContent?: {
+        text: string;
+        startLine: number;
+    };
+    summary?: {
+        lines: number;
+        elidedSpans: number;
+        elidedLines: number;
+    };
+    /** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
+    conflictCount?: number;
+}
+type ReadParams = ReadToolInput;
+/**
+ * Read tool implementation.
+ *
+ * Reads files with support for images, converted documents (via markit), and text.
+ * Directories return a formatted listing with modification times.
+ */
+export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "read";
+    readonly label = "Read";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    readonly nonAbortable = true;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;
+}
+interface ReadRenderArgs {
+    path?: string;
+    file_path?: string;
+    sel?: string;
+    offset?: number;
+    limit?: number;
+    raw?: boolean;
+}
+export declare const readToolRenderer: {
+    renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ReadToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: ReadRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/recipe/index.d.ts

@@ -0,0 +1,45 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import type { ToolSession } from "..";
+import { type BashRenderContext, type BashToolDetails } from "../bash";
+import { type RecipeRenderArgs } from "./render";
+import { type DetectedRunner } from "./runner";
+declare const recipeSchema: z.ZodObject<{
+    op: z.ZodString;
+}, z.core.$strict>;
+type RecipeParams = z.infer<typeof recipeSchema>;
+type RecipeRenderResult = {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: BashToolDetails;
+    isError?: boolean;
+};
+export declare class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
+    #private;
+    readonly name = "recipe";
+    readonly label = "Run";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodString;
+    }, z.core.$strict>;
+    readonly strict = true;
+    readonly concurrency = "exclusive";
+    readonly loadMode = "discoverable";
+    readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
+    readonly mergeCallAndResult = true;
+    readonly inline = true;
+    readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
+    readonly renderResult: (result: RecipeRenderResult, options: RenderResultOptions & {
+        renderContext?: BashRenderContext;
+    }, uiTheme: Theme, args?: RecipeRenderArgs) => Component;
+    constructor(session: ToolSession, runners: DetectedRunner[]);
+    static createIf(session: ToolSession): Promise<RecipeTool | null>;
+    execute(toolCallId: string, { op }: RecipeParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+}
+export * from "./runner";
+export { tasksFromCargoMetadata } from "./runners/cargo";

package/dist/types/tools/recipe/render.d.ts

@@ -0,0 +1,36 @@
+import type { DetectedRunner } from "./runner";
+export interface RecipeRenderArgs {
+    op?: string;
+    __partialJson?: string;
+    [key: string]: unknown;
+}
+export declare function createRecipeToolRenderer(runners: DetectedRunner[]): {
+    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
+    renderResult(result: {
+        content: {
+            type: string;
+            text?: string;
+        }[];
+        details?: import("..").BashToolDetails;
+        isError?: boolean;
+    }, options: import("../..").RenderResultOptions & {
+        renderContext?: import("..").BashRenderContext;
+    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};
+export declare const recipeToolRenderer: {
+    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
+    renderResult(result: {
+        content: {
+            type: string;
+            text?: string;
+        }[];
+        details?: import("..").BashToolDetails;
+        isError?: boolean;
+    }, options: import("../..").RenderResultOptions & {
+        renderContext?: import("..").BashRenderContext;
+    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};

package/dist/types/tools/recipe/runner.d.ts

@@ -0,0 +1,60 @@
+export interface RunnerTask {
+    name: string;
+    doc?: string;
+    /** Parameter names only; used for the `name foo bar` signature line in the description. */
+    parameters: string[];
+    /** Override for this specific task, e.g. `cargo run --package crate --bin`. */
+    commandPrefix?: string;
+    /** Token passed to the runner command; defaults to `name`. Used when display names are namespaced. */
+    commandName?: string;
+    /** Working directory for the task, relative to the session cwd; absent means the runner's root cwd. */
+    cwd?: string;
+}
+export interface DetectedRunner {
+    id: string;
+    label: string;
+    /** Resolved shell prefix, e.g. "just" or "bun run" or "make". */
+    commandPrefix: string;
+    tasks: RunnerTask[];
+}
+export interface TaskRunner {
+    id: string;
+    label: string;
+    /**
+     * Probe `cwd` for the manifest, the binary, and the task list.
+     * Returns null when this runner does not apply.
+     */
+    detect(cwd: string): Promise<DetectedRunner | null>;
+}
+interface PromptTaskModel {
+    name: string;
+    paramSig?: string;
+    command?: string;
+    doc?: string;
+    cwd?: string;
+}
+interface PromptRunnerModel {
+    id: string;
+    label: string;
+    commandPrefix: string;
+    tasks: PromptTaskModel[];
+    hiddenTaskCount?: number;
+}
+export interface RecipePromptModel {
+    [key: string]: unknown;
+    hasMultipleRunners: boolean;
+    ambiguityExampleRunner?: string;
+    ambiguityExampleTask?: string;
+    runners: PromptRunnerModel[];
+}
+export interface ResolvedTask {
+    command: string;
+    cwd?: string;
+}
+export declare function resolveCommand(op: string, runners: DetectedRunner[]): ResolvedTask;
+export declare function resolveTaskFromOp(op: string | undefined, runners: DetectedRunner[]): ResolvedTask | undefined;
+export declare function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
+export declare function cwdFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
+export declare function titleFromOp(op: string | undefined, runners: DetectedRunner[]): string;
+export declare function buildPromptModel(runners: DetectedRunner[]): RecipePromptModel;
+export {};

package/dist/types/tools/recipe/runners/cargo.d.ts

@@ -0,0 +1,16 @@
+import type { RunnerTask, TaskRunner } from "../runner";
+export interface CargoMetadataTarget {
+    kind?: string[];
+    name?: string;
+}
+export interface CargoMetadataPackage {
+    id?: string;
+    name?: string;
+    targets?: CargoMetadataTarget[];
+}
+export interface CargoMetadata {
+    packages?: CargoMetadataPackage[];
+    workspace_members?: string[];
+}
+export declare function tasksFromCargoMetadata(metadata: CargoMetadata): RunnerTask[];
+export declare const cargoRunner: TaskRunner;

package/dist/types/tools/recipe/runners/index.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const RUNNERS: TaskRunner[];

package/dist/types/tools/recipe/runners/just.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const justRunner: TaskRunner;

package/dist/types/tools/recipe/runners/make.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const makeRunner: TaskRunner;

package/dist/types/tools/recipe/runners/pkg.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const pkgRunner: TaskRunner;

package/dist/types/tools/recipe/runners/task.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunner } from "../runner";
+export declare const taskRunner: TaskRunner;

package/dist/types/tools/render-mermaid.d.ts

@@ -0,0 +1,37 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+declare const renderMermaidSchema: z.ZodObject<{
+    mermaid: z.ZodString;
+    config: z.ZodOptional<z.ZodObject<{
+        useAscii: z.ZodOptional<z.ZodBoolean>;
+        paddingX: z.ZodOptional<z.ZodNumber>;
+        paddingY: z.ZodOptional<z.ZodNumber>;
+        boxBorderPadding: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RenderMermaidParams = z.infer<typeof renderMermaidSchema>;
+export interface RenderMermaidToolDetails {
+    artifactId?: string;
+}
+export declare class RenderMermaidTool implements AgentTool<typeof renderMermaidSchema, RenderMermaidToolDetails> {
+    private readonly session;
+    readonly name = "render_mermaid";
+    readonly label = "RenderMermaid";
+    readonly summary = "Render a Mermaid diagram to an image";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        mermaid: z.ZodString;
+        config: z.ZodOptional<z.ZodObject<{
+            useAscii: z.ZodOptional<z.ZodBoolean>;
+            paddingX: z.ZodOptional<z.ZodNumber>;
+            paddingY: z.ZodOptional<z.ZodNumber>;
+            boxBorderPadding: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: RenderMermaidParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<RenderMermaidToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<RenderMermaidToolDetails>>;
+}
+export {};