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

package/dist/types/eval/js/shared/helpers.d.ts

@@ -0,0 +1,38 @@
+import type { JsStatusEvent } from "./types";
+export interface HelperOptions {
+    path?: string;
+    hidden?: boolean;
+    maxDepth?: number;
+    limit?: number;
+    offset?: number;
+    reverse?: boolean;
+    unique?: boolean;
+    count?: boolean;
+}
+/**
+ * Inputs the helper factory needs from its host runtime. `cwd` is a getter so the runtime
+ * can update it between cells (e.g. when the agent's session cwd changes) without
+ * recreating helpers.
+ */
+export interface HelperContext {
+    cwd(): string;
+    env: Map<string, string>;
+    emitStatus(event: JsStatusEvent): void;
+}
+/**
+ * The set of functions exposed to user code via `globalThis.__omp_helpers__`. The JS
+ * prelude reads from this bag and attaches short aliases (`read`, `write`, `tree`, ...)
+ * onto the global scope.
+ */
+export interface HelperBundle {
+    read(rawPath: string, options?: HelperOptions): Promise<string>;
+    writeFile(rawPath: string, data: unknown): Promise<string>;
+    append(rawPath: string, content: string): Promise<string>;
+    sortText(text: string, options?: HelperOptions): string;
+    uniqText(text: string, options?: HelperOptions): string | Array<[number, string]>;
+    counter(items: string | string[], options?: HelperOptions): Array<[number, string]>;
+    diff(rawA: string, rawB: string): Promise<string>;
+    tree(searchPath?: string, options?: HelperOptions): Promise<string>;
+    env(key?: string, value?: string): string | Record<string, string> | undefined;
+}
+export declare function createHelpers(ctx: HelperContext): HelperBundle;

package/dist/types/eval/js/shared/indirect-eval.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Indirect eval — runs in the host's global scope, isolating bindings declared with
+ * `const`/`let` from this module's closure. Used by both the JS eval worker and the
+ * browser tab worker to execute user-supplied source without `node:vm`.
+ *
+ * Why not vm.runInContext: Bun crashes the parent process with SIGTRAP when
+ * `Worker.terminate()` fires while a worker is mid-`vm.runInContext` synchronous loop.
+ * Indirect eval does not trip that bug.
+ *
+ * The optional `filename` is appended as a `//# sourceURL=...` pragma so V8 attributes
+ * stack frames to the user cell instead of `<anonymous>`.
+ */
+export declare function indirectEval(source: string, filename?: string): unknown;
+export declare function awaitMaybePromise<T>(value: T | Promise<T>): Promise<T>;

package/dist/types/eval/js/shared/prelude.d.ts

@@ -0,0 +1 @@
+export declare const JAVASCRIPT_PRELUDE_SOURCE: string;

package/dist/types/eval/js/shared/rewrite-imports.d.ts

@@ -0,0 +1,6 @@
+export declare function rewriteImports(code: string): string;
+export declare function wrapCode(code: string): {
+    source: string;
+    asyncWrapped: boolean;
+    finalExpressionReturned: boolean;
+};

package/dist/types/eval/js/shared/runtime.d.ts

@@ -0,0 +1,47 @@
+import { type HelperBundle } from "./helpers";
+import type { JsDisplayOutput } from "./types";
+/**
+ * Per-run callbacks. Returned by `getHooks()` on each helper/tool/display invocation so
+ * the embedding worker can route emissions to the currently active run. Returning `null`
+ * makes status/display/tool calls reject with an error — useful for guarding against
+ * helpers being invoked outside a run window.
+ */
+export interface RuntimeHooks {
+    onText(chunk: string): void;
+    onDisplay(output: JsDisplayOutput): void;
+    callTool(name: string, args: unknown): Promise<unknown>;
+}
+export interface RuntimeOptions {
+    initialCwd: string;
+    sessionId: string;
+    /** Resolve hooks for the run currently in flight, or `null` if nothing is active. */
+    getHooks(): RuntimeHooks | null;
+    /**
+     * Extra globals installed alongside `__omp_helpers__` / prelude. Use for stable, lifetime-
+     * of-the-worker bindings (e.g. browser's `page`, `browser`). Per-run scope should be set
+     * via `setRunScope()` instead.
+     */
+    extraGlobals?: Record<string, unknown>;
+}
+/**
+ * Shared JS runtime for the eval worker and the browser tab worker. Owns the prelude,
+ * helper bag, console bridge, and indirect-eval execution. Emits text/display/tool-call
+ * back through `RuntimeHooks` that the embedder supplies — wire format is the embedder's
+ * concern.
+ */
+export declare class JsRuntime {
+    #private;
+    readonly helpers: HelperBundle;
+    readonly sessionId: string;
+    constructor(opts: RuntimeOptions);
+    get cwd(): string;
+    setCwd(cwd: string): void;
+    /**
+     * Install per-run globals. Intended for run-scoped state (browser's `tab`, `display`
+     * overrides, etc.). Overwrites previous assignments — caller is responsible for any
+     * cleanup it wants.
+     */
+    setRunScope(scope: Record<string, unknown>): void;
+    run(code: string, filename?: string): Promise<unknown>;
+    displayValue(value: unknown): void;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Structured status payload emitted by helpers (`read`, `write`, `tree`, etc.) and the
+ * tool-call bridge. Surfaces to the model as part of `displays` so it has machine-readable
+ * context about what side effects happened.
+ */
+export interface JsStatusEvent {
+    op: string;
+    [key: string]: unknown;
+}
+/**
+ * One unit of structured output from a JS eval cell. `text` chunks flow through a separate
+ * channel.
+ */
+export type JsDisplayOutput = {
+    type: "json";
+    data: unknown;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "status";
+    event: JsStatusEvent;
+};

package/dist/types/eval/js/tool-bridge.d.ts

@@ -0,0 +1,18 @@
+import type { ToolSession } from "../../tools";
+import type { JsStatusEvent } from "./shared/types";
+export type { JsStatusEvent } from "./shared/types";
+interface ToolBridgeOptions {
+    session: ToolSession;
+    signal?: AbortSignal;
+    emitStatus?: (event: JsStatusEvent) => void;
+}
+type ToolValue = string | {
+    text: string;
+    details?: unknown;
+    images?: Array<{
+        mimeType: string;
+        data: string;
+    }>;
+    hasError?: boolean;
+};
+export declare function callSessionTool(name: string, args: unknown, options: ToolBridgeOptions): Promise<ToolValue>;

package/dist/types/eval/js/worker-core.d.ts

@@ -0,0 +1,5 @@
+import type { Transport } from "./worker-protocol";
+export declare class WorkerCore {
+    #private;
+    constructor(transport: Transport);
+}

package/dist/types/eval/js/worker-entry.d.ts

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

package/dist/types/eval/js/worker-protocol.d.ts

@@ -0,0 +1,77 @@
+import type { JsDisplayOutput } from "./shared/types";
+export type { JsDisplayOutput } from "./shared/types";
+export interface SessionSnapshot {
+    cwd: string;
+    sessionId: string;
+}
+export interface RunErrorPayload {
+    name?: string;
+    message: string;
+    stack?: string;
+    isAbort?: boolean;
+    isToolError?: boolean;
+}
+export type ToolReply = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: RunErrorPayload;
+};
+export type WorkerInbound = {
+    type: "init";
+    snapshot: SessionSnapshot;
+} | {
+    type: "run";
+    runId: string;
+    code: string;
+    filename: string;
+    snapshot: SessionSnapshot;
+} | {
+    type: "tool-reply";
+    id: string;
+    reply: ToolReply;
+} | {
+    type: "close";
+};
+export type WorkerOutbound = {
+    type: "ready";
+} | {
+    type: "init-failed";
+    error: RunErrorPayload;
+} | {
+    type: "text";
+    runId: string;
+    chunk: string;
+} | {
+    type: "display";
+    runId: string;
+    output: JsDisplayOutput;
+} | {
+    type: "tool-call";
+    id: string;
+    runId: string;
+    name: string;
+    args: unknown;
+} | {
+    type: "result";
+    runId: string;
+    ok: true;
+} | {
+    type: "result";
+    runId: string;
+    ok: false;
+    error: RunErrorPayload;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+} | {
+    type: "closed";
+};
+export interface Transport {
+    send(msg: WorkerOutbound): void;
+    onMessage(handler: (msg: WorkerInbound) => void): () => void;
+    close(): void;
+}

package/dist/types/eval/py/display.d.ts

@@ -0,0 +1,25 @@
+/** Status event emitted by prelude helpers for TUI rendering. */
+export interface PythonStatusEvent {
+    /** Operation name (e.g., "find", "read", "write") */
+    op: string;
+    /** Additional data fields (count, path, pattern, etc.) */
+    [key: string]: unknown;
+}
+export type KernelDisplayOutput = {
+    type: "json";
+    data: unknown;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "markdown";
+} | {
+    type: "status";
+    event: PythonStatusEvent;
+};
+/** Render a MIME bundle into text + structured outputs. */
+export declare function renderKernelDisplay(content: Record<string, unknown>): Promise<{
+    text: string;
+    outputs: KernelDisplayOutput[];
+}>;

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

@@ -0,0 +1,83 @@
+import type { ToolSession } from "../../tools";
+import type { JsStatusEvent } from "../js/shared/types";
+import type { KernelDisplayOutput } from "./display";
+import { type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
+export type PythonKernelMode = "session" | "per-call";
+export interface PythonExecutorOptions {
+    /** Working directory for command execution */
+    cwd?: string;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+    /** Absolute wall-clock deadline in milliseconds since epoch */
+    deadlineMs?: number;
+    /** Callback for streaming output chunks (already sanitized) */
+    onChunk?: (chunk: string) => Promise<void> | void;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Session identifier for kernel reuse */
+    sessionId?: string;
+    /** Logical owner identifier for retained kernel cleanup */
+    kernelOwnerId?: string;
+    /** Kernel mode (session reuse vs per-call) */
+    kernelMode?: PythonKernelMode;
+    /** Restart the kernel before executing */
+    reset?: boolean;
+    /** Session file path for accessing task outputs */
+    sessionFile?: string;
+    /**
+     * Effective artifacts directory for the current session. Subagents share
+     * the parent's directory, so this can differ from `sessionFile`'s sibling
+     * dir. When present, exported to the kernel as `PI_ARTIFACTS_DIR` and
+     * preferred over `PI_SESSION_FILE`-derived paths.
+     */
+    artifactsDir?: string;
+    /** Artifact path/id for full output storage */
+    artifactPath?: string;
+    artifactId?: string;
+    /**
+     * ToolSession used to resolve host-side `tool.<name>(args)` calls made from
+     * the Python prelude's bridge proxy. When omitted, the bridge env vars are
+     * not injected and any `tool.foo(...)` raises in Python.
+     */
+    toolSession?: ToolSession;
+    /** Callback for status events emitted by tool bridge invocations. */
+    emitStatus?: (event: JsStatusEvent) => void;
+    /** @internal Bridge session id, set by `executePython` before delegating. */
+    bridgeSessionId?: string;
+    /** @internal Bridge endpoint info, set by `executePython` before delegating. */
+    bridge?: {
+        url: string;
+        token: string;
+    };
+}
+export interface PythonKernelExecutor {
+    execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
+}
+export interface PythonResult {
+    /** Combined stdout + stderr output (sanitized, possibly truncated) */
+    output: string;
+    /** Execution exit code (0 ok, 1 error, undefined if cancelled) */
+    exitCode: number | undefined;
+    /** Whether the execution was cancelled via signal */
+    cancelled: boolean;
+    /** Whether the output was truncated */
+    truncated: boolean;
+    /** Artifact ID if full output was saved to artifact storage */
+    artifactId?: string;
+    /** Total number of lines in the output stream */
+    totalLines: number;
+    /** Total number of bytes in the output stream */
+    totalBytes: number;
+    /** Number of lines included in the output text */
+    outputLines: number;
+    /** Number of bytes included in the output text */
+    outputBytes: number;
+    /** Rich display outputs captured from display_data/execute_result */
+    displayOutputs: KernelDisplayOutput[];
+    /** Whether stdin was requested */
+    stdinRequested: boolean;
+}
+export declare function disposeAllKernelSessions(): Promise<void>;
+export declare function disposeKernelSessionsByOwner(ownerId: string): Promise<void>;
+export declare function executePythonWithKernel(kernel: PythonKernelExecutor, code: string, options?: PythonExecutorOptions): Promise<PythonResult>;
+export declare function executePython(code: string, options?: PythonExecutorOptions): Promise<PythonResult>;

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

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

package/dist/types/eval/py/kernel.d.ts

@@ -0,0 +1,55 @@
+import { type KernelDisplayOutput } from "./display";
+export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
+export { renderKernelDisplay } from "./display";
+export interface KernelExecuteOptions {
+    signal?: AbortSignal;
+    onChunk?: (text: string) => Promise<void> | void;
+    onDisplay?: (output: KernelDisplayOutput) => Promise<void> | void;
+    timeoutMs?: number;
+    silent?: boolean;
+    storeHistory?: boolean;
+    allowStdin?: boolean;
+}
+export interface KernelExecuteResult {
+    status: "ok" | "error";
+    executionCount?: number;
+    error?: {
+        name: string;
+        value: string;
+        traceback: string[];
+    };
+    cancelled: boolean;
+    timedOut: boolean;
+    stdinRequested: boolean;
+}
+export interface KernelShutdownResult {
+    confirmed: boolean;
+}
+interface KernelLifecycleOptions {
+    signal?: AbortSignal;
+    deadlineMs?: number;
+}
+interface KernelStartOptions extends KernelLifecycleOptions {
+    cwd: string;
+    env?: Record<string, string | undefined>;
+}
+interface KernelShutdownOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface PythonKernelAvailability {
+    ok: boolean;
+    pythonPath?: string;
+    reason?: string;
+}
+export declare function checkPythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability>;
+export declare class PythonKernel {
+    #private;
+    readonly id: string;
+    private constructor();
+    static start(options: KernelStartOptions): Promise<PythonKernel>;
+    isAlive(): boolean;
+    execute(code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult>;
+    interrupt(): Promise<void>;
+    shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult>;
+}

package/dist/types/eval/py/prelude.d.ts

@@ -0,0 +1 @@
+export declare const PYTHON_PRELUDE: string;

package/dist/types/eval/py/runtime.d.ts

@@ -0,0 +1,21 @@
+export interface PythonRuntime {
+    /** Path to python executable */
+    pythonPath: string;
+    /** Filtered environment variables */
+    env: Record<string, string | undefined>;
+    /** Path to virtual environment, if detected */
+    venvPath?: string;
+}
+/**
+ * Filter environment variables to a safe allowlist for Python subprocesses.
+ * Removes sensitive API keys and limits to known-safe variables.
+ */
+export declare function filterEnv(env: Record<string, string | undefined>): Record<string, string | undefined>;
+/**
+ * Detect virtual environment path from VIRTUAL_ENV or common locations.
+ */
+export declare function resolveVenvPath(cwd: string): string | undefined;
+/**
+ * Resolve Python runtime including executable path, environment, and venv detection.
+ */
+export declare function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime;

package/dist/types/eval/py/tool-bridge.d.ts

@@ -0,0 +1,20 @@
+import type { ToolSession } from "../../tools";
+import { type JsStatusEvent } from "../js/tool-bridge";
+export interface PyToolBridgeEntry {
+    toolSession: ToolSession;
+    signal?: AbortSignal;
+    emitStatus?: (event: JsStatusEvent) => void;
+}
+export interface PyToolBridgeInfo {
+    url: string;
+    token: string;
+}
+/** Starts the bridge server lazily and returns its connection info. */
+export declare function ensurePyToolBridge(): Promise<PyToolBridgeInfo>;
+/**
+ * Register a tool session for the duration of one execution. The returned
+ * function MUST be called to remove the entry once execution finishes.
+ */
+export declare function registerPyToolBridge(sessionId: string, entry: PyToolBridgeEntry): () => void;
+/** Stop the bridge and clear registrations. Test-only / shutdown helper. */
+export declare function disposePyToolBridge(): Promise<void>;

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

@@ -0,0 +1,52 @@
+/** Runtime backend that an eval cell dispatches to. */
+export type EvalLanguage = "python" | "js";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { OutputMeta } from "../tools/output-meta";
+/** Status event emitted by prelude helpers (python or js) for TUI rendering. */
+export interface EvalStatusEvent {
+    op: string;
+    [key: string]: unknown;
+}
+/** Display output captured during eval execution. Union of python and js shapes. */
+export type EvalDisplayOutput = {
+    type: "json";
+    data: unknown;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "markdown";
+    text?: string;
+} | {
+    type: "status";
+    event: EvalStatusEvent;
+};
+/** Per-cell execution result for transcript rendering. */
+export interface EvalCellResult {
+    index: number;
+    title?: string;
+    code: string;
+    language?: EvalLanguage;
+    output: string;
+    status: "pending" | "running" | "complete" | "error";
+    durationMs?: number;
+    exitCode?: number;
+    statusEvents?: EvalStatusEvent[];
+    hasMarkdown?: boolean;
+}
+/** Tool result detail object surfaced to the UI/transcript. */
+export interface EvalToolDetails {
+    cells?: EvalCellResult[];
+    jsonOutputs?: unknown[];
+    images?: ImageContent[];
+    statusEvents?: EvalStatusEvent[];
+    isError?: boolean;
+    meta?: OutputMeta;
+    /** First backend that produced cells. Kept for transcript compatibility. */
+    language?: EvalLanguage;
+    /** Backends that produced cells in this call, in first-use order. */
+    languages?: EvalLanguage[];
+    /** Optional human-readable notice (e.g. fallback explanation). */
+    notice?: string;
+}

package/dist/types/exa/factory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared factory for creating Exa tools with consistent error handling and response formatting.
+ */
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { ExaRenderDetails } from "./types";
+/** Creates an Exa tool with standardized API key handling, error wrapping, and optional search response formatting. */
+export declare function createExaTool(name: string, label: string, description: string, parameters: TSchema, mcpToolName: string, options?: {
+    /** When true, checks isSearchResponse and formats with formatSearchResults. Default: true */
+    formatResponse?: boolean;
+    /** Transform params before passing to callExaTool */
+    transformParams?: (params: Record<string, unknown>) => Record<string, unknown>;
+}): CustomTool<TSchema, ExaRenderDetails>;

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

@@ -0,0 +1,20 @@
+/**
+ * Exa MCP Tools
+ *
+ * 22 tools for Exa's MCP servers:
+ * - 4 search tools (search, deep, code, crawl)
+ * - 1 LinkedIn search tool
+ * - 1 company research tool
+ * - 2 researcher tools (start, poll)
+ * - 14 websets tools (CRUD, items, search, enrichment, monitor)
+ */
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { ExaRenderDetails } from "./types";
+/** All Exa tools (22 total) - static export for backward compatibility */
+export declare const exaTools: CustomTool<any, ExaRenderDetails>[];
+export * from "./mcp-client";
+export { renderExaCall, renderExaResult } from "./render";
+export { researcherTools } from "./researcher";
+export { searchTools } from "./search";
+export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult, MCPToolWrapperConfig } from "./types";
+export { websetsTools } from "./websets";

package/dist/types/exa/mcp-client.d.ts

@@ -0,0 +1,45 @@
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { CustomTool, CustomToolResult } from "../extensibility/custom-tools/types";
+import type { ExaRenderDetails, ExaSearchResponse, MCPTool, MCPToolWrapperConfig } from "./types";
+/** Find EXA_API_KEY from Bun.env or .env files */
+export declare function findApiKey(): string | null;
+/** Fetch available tools from Exa MCP */
+export declare function fetchExaTools(apiKey: string | null, toolNames: string[]): Promise<MCPTool[]>;
+/** Fetch available tools from Websets MCP */
+export declare function fetchWebsetsTools(apiKey: string): Promise<MCPTool[]>;
+/** Call a tool on Exa MCP (simplified: toolName as first arg for easier use) */
+export declare function callExaTool(toolName: string, args: Record<string, unknown>, apiKey: string | null): Promise<unknown>;
+/** Call a tool on Websets MCP */
+export declare function callWebsetsTool(apiKey: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+/** Format search results for LLM */
+export declare function formatSearchResults(data: ExaSearchResponse): string;
+/**
+ * Format a non-search MCP response as human-readable text.
+ * Handles objects, arrays, primitives, and common MCP response shapes.
+ */
+export declare function formatGenericResponse(data: unknown): string;
+/** Check if result is a search response */
+export declare function isSearchResponse(data: unknown): data is ExaSearchResponse;
+/** Fetch and cache MCP tool schema */
+export declare function fetchMCPToolSchema(apiKey: string, mcpToolName: string, isWebsetsTool?: boolean): Promise<MCPTool | null>;
+/**
+ * CustomTool dynamically created from MCP tool metadata.
+ *
+ * This allows tools to be generated from MCP server schemas without hardcoding,
+ * reducing drift when MCP servers add new parameters.
+ */
+export declare class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
+    private readonly config;
+    readonly parameters: TSchema;
+    readonly description: string;
+    readonly name: string;
+    readonly label: string;
+    constructor(config: MCPToolWrapperConfig, parameters: TSchema, description: string);
+    execute(_toolCallId: string, params: unknown, _onUpdate?: unknown, _ctx?: unknown, _signal?: AbortSignal): Promise<CustomToolResult<ExaRenderDetails>>;
+}
+/**
+ * Create a CustomTool by fetching schema from MCP server.
+ *
+ * Falls back to provided fallback schema if MCP fetch fails.
+ */
+export declare function createMCPToolFromServer(apiKey: string, config: MCPToolWrapperConfig, fallbackSchema: TSchema, fallbackDescription: string): Promise<MCPWrappedTool>;

package/dist/types/exa/render.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Exa TUI Rendering
+ *
+ * Tree-based rendering with collapsed/expanded states for Exa search results.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ExaRenderDetails } from "./types";
+/** Render Exa result with tree-based layout */
+export declare function renderExaResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: ExaRenderDetails;
+}, options: RenderResultOptions, uiTheme: Theme): Component;
+/** Render Exa call (query/args preview) */
+export declare function renderExaCall(args: Record<string, unknown>, toolName: string, uiTheme: Theme): Component;

package/dist/types/exa/researcher.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Exa Researcher Tools
+ *
+ * Async research tasks with polling for completion.
+ */
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { ExaRenderDetails } from "./types";
+export declare const researcherTools: CustomTool<TSchema, ExaRenderDetails>[];

package/dist/types/exa/search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Exa Search Tools
+ *
+ * Basic neural/keyword search, deep research, code search, and URL crawling.
+ */
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { ExaRenderDetails } from "./types";
+export declare const searchTools: CustomTool<TSchema, ExaRenderDetails>[];