@sayknow-cli/coding-agent 0.4.2 → 0.4.3

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

@@ -0,0 +1,390 @@
+import type { AgentTelemetryConfig, AgentTool } from "@sayknow-cli/agent-core";
+import type { Model, ServiceTier, ToolChoice } from "@sayknow-cli/ai";
+import type { PromptTemplate } from "../config/prompt-templates";
+import type { Settings } from "../config/settings";
+import type { Skill } from "../extensibility/skills";
+import type { GoalModeState, GoalRuntime } from "../goals";
+import type { HindsightSessionState } from "../hindsight/state";
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
+import type { PlanModeState } from "../plan-mode/state";
+import type { AgentRegistry } from "../registry/agent-registry";
+import type { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
+import type { ArtifactManager } from "../session/artifacts";
+import type { ClientBridge } from "../session/client-bridge";
+import type { CustomMessage } from "../session/messages";
+import type { ToolChoiceQueue } from "../session/tool-choice-queue";
+import type { SkillActiveEntry } from "../skill-state/active-state";
+import type { AgentOutputManager } from "../task/output-manager";
+import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
+import type { EventBus } from "../utils/event-bus";
+import type { WorkspaceTree } from "../workspace-tree";
+import type { BashRestrictionProfile } from "./bash-allowed-prefixes";
+import { type CheckpointState } from "./checkpoint";
+import { type TodoPhase } from "./todo-write";
+export * from "../edit";
+export * from "../goals";
+export * from "../lsp";
+export * from "../session/streaming-output";
+export * from "../task";
+export * from "../web/search";
+export * from "./ask";
+export * from "./ast-edit";
+export * from "./ast-grep";
+export * from "./bash";
+export * from "./bisect";
+export * from "./browser";
+export * from "./calculator";
+export * from "./checkpoint";
+export * from "./computer";
+export * from "./cron";
+export * from "./debug";
+export * from "./eval";
+export * from "./find";
+export * from "./gh";
+export * from "./image-gen";
+export * from "./irc";
+export * from "./job";
+export * from "./monitor";
+export * from "./read";
+export * from "./recipe";
+export * from "./render-mermaid";
+export * from "./resolve";
+export * from "./review";
+export * from "./search";
+export * from "./search-tool-bm25";
+export * from "./skill";
+export * from "./skill-discovery";
+export * from "./ssh";
+export * from "./subagent";
+export * from "./telegram-send";
+export * from "./todo-write";
+export * from "./vim";
+export * from "./write";
+export * from "./yield";
+/** Tool type (AgentTool from pi-ai) */
+export type Tool = AgentTool<any, any, any>;
+export type ContextFileEntry = {
+    path: string;
+    content: string;
+    depth?: number;
+};
+export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
+/** A typed remote action available to an ask answer source. */
+export type AskRemoteControlId = "navigation_forward";
+export interface AskRemoteControl {
+    id: AskRemoteControlId;
+    kind: "navigation";
+    label: "Next" | "Done";
+    enabled: boolean;
+}
+export interface AskAnswerRequest {
+    question: string;
+    options: string[];
+    interaction: "selector" | "custom_editor" | "clarification_editor";
+    controls: readonly AskRemoteControl[];
+}
+export type AskRemoteInteraction = {
+    kind: "value";
+    value: string;
+} | {
+    kind: "control";
+    controlId: AskRemoteControlId;
+};
+export type AskSettlement = {
+    kind: "commit";
+} | {
+    kind: "resolve_without_commit";
+    reason: "toggle" | "other_transition" | "clarification_transition" | "clarification_submitted" | "empty_navigation" | "back_navigation" | "cancelled" | "aborted" | "timed_out" | "exception" | "shutdown";
+} | {
+    kind: "invalid";
+    reason: "invalid_option" | "invalid_control" | "invalid_structured_answer" | "empty_custom" | "empty_clarification";
+};
+export type AskSelectedAckOutcome = {
+    status: "delivered";
+    messageId: number;
+} | {
+    status: "failed";
+    reason: "unsupported" | "no_participant" | "ambiguous_participant" | "route_missing" | "expired" | "cancelled" | "telegram_rejected" | "session_closed";
+} | {
+    status: "unknown";
+    reason: "transport_ambiguous" | "origin_disconnected" | "host_timeout" | "shutdown";
+};
+export type AskSettlementResult = {
+    kind: "committed";
+    ack: AskSelectedAckOutcome;
+} | {
+    kind: "resolved_without_commit";
+} | {
+    kind: "invalid_closed";
+};
+export interface AskRemoteReceipt {
+    source: "remote";
+    interaction: AskRemoteInteraction;
+    settle(value: AskSettlement): Promise<AskSettlementResult>;
+}
+export type AskAnswerSourceResult = AskRemoteReceipt | string | undefined;
+/**
+ * Source of remote answers for interactive asks. `awaitAnswer` remains the legacy
+ * wire for existing integrations; typed sources opt into `awaitAnswerRequest`.
+ * This keeps a string-only source from accidentally acquiring acknowledgement
+ * authority while allowing SDK-routed interactions to settle durably.
+ */
+export interface AskAnswerSource {
+    awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+    awaitAnswerRequest?(request: AskAnswerRequest, signal?: AbortSignal): Promise<AskAnswerSourceResult>;
+}
+/** Session context for tool factories */
+export interface ToolSession {
+    /** Current working directory */
+    cwd: string;
+    /** Whether UI is available */
+    hasUI: boolean;
+    /** Whether this session will bind a workflow-gate emitter after tool construction. */
+    workflowGateEligible?: boolean;
+    /** Skip Python kernel availability check and warmup */
+    skipPythonPreflight?: boolean;
+    /** Pre-loaded context files (AGENTS.md, etc) */
+    contextFiles?: ContextFileEntry[];
+    /** Pre-loaded workspace tree (forwarded to subagents to skip re-scanning) */
+    workspaceTree?: WorkspaceTree;
+    /** Pre-loaded skills */
+    skills?: Skill[];
+    /** Currently executing skill prompt, when this tool session is inside one. */
+    getActiveSkillState?: () => Pick<SkillActiveEntry, "skill" | "session_id"> | undefined;
+    /** Get the active skill prompt's current phase so the skill tool can apply
+     *  its terminal-phase chain guard. Returns the raw phase string or undefined
+     *  when no active skill (or accessor) is available. */
+    getActiveSkillPhase?: () => string | undefined;
+    /** Pre-loaded prompt templates */
+    promptTemplates?: PromptTemplate[];
+    /** Whether LSP integrations are enabled */
+    enableLsp?: boolean;
+    /** Whether an edit-capable tool is available in this session (controls hashline output) */
+    hasEditTool?: boolean;
+    /** Event bus for tool/extension communication */
+    eventBus?: EventBus;
+    /** Output schema for structured completion (subagents) */
+    outputSchema?: unknown;
+    /** Whether to include the yield tool by default */
+    requireYieldTool?: boolean;
+    /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
+    taskDepth?: number;
+    /** Current role-agent type/name for nested task sessions. */
+    currentAgentType?: string;
+    /** Get session file */
+    getSessionFile: () => string | null;
+    /** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
+    getEvalKernelOwnerId?: () => string | null;
+    /** Reject new eval (python or js) work once session disposal has started. */
+    assertEvalExecutionAllowed?: () => void;
+    /** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
+    trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
+    /** Register a safe request handler that asks a managed foreground bash call to fold into a background job. */
+    registerForegroundBashBackgroundRequestHandler?: (handler: () => void) => () => void;
+    /** Whether a managed foreground bash call is currently foldable into a background job. */
+    hasForegroundBashBackgroundRequestHandler?: () => boolean;
+    /** Request that the active managed foreground bash call fold into a background job, if supported. */
+    requestForegroundBashBackground?: () => boolean;
+    /** Get session ID */
+    getSessionId?: () => string | null;
+    /** Whether local:// must use external managed scratch instead of artifacts/local. */
+    isManagedSessionDestination?: () => boolean;
+    /** Get Hindsight runtime state for this agent session. */
+    getHindsightSessionState?: () => HindsightSessionState | undefined;
+    /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
+    getAgentId?: () => string | null;
+    /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    /** Purge undelivered queued custom messages matching the predicate. Returns counts. */
+    purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
+    getToolByName?: (name: string) => AgentTool | undefined;
+    /** Agent registry for IRC routing across live sessions. */
+    agentRegistry?: AgentRegistry;
+    /** Optional restricted bash command prefixes for read-only role agents and constrained modes. */
+    bashAllowedPrefixes?: string[];
+    /** Restriction policy for sessions that deliberately expose a narrow bash surface. */
+    bashRestrictionProfile?: BashRestrictionProfile;
+    /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
+    discoverableToolAllowedNames?: readonly string[];
+    /** Throw instead of warn when toolNames contains an unknown name. */
+    strictToolNames?: boolean;
+    /** Get artifacts directory for artifact:// URLs */
+    getArtifactsDir?: () => string | null;
+    /** Get the ArtifactManager backing this session (shared across parent + subagents). */
+    getArtifactManager?: () => ArtifactManager | null;
+    /** Allocate a new artifact path and ID for session-scoped truncated output. */
+    allocateOutputArtifact?: (toolType: string) => Promise<{
+        id?: string;
+        path?: string;
+    }>;
+    /** Get session spawns */
+    getSessionSpawns: () => string | null;
+    /** Get resolved model string if explicitly set for this session */
+    getModelString?: () => string | undefined;
+    /** Current model, when selected. */
+    model?: Model;
+    /** Get the current session model string, regardless of how it was chosen */
+    getActiveModelString?: () => string | undefined;
+    /** Auth storage for passing to subagents (avoids re-discovery) */
+    authStorage?: import("../session/auth-storage").AuthStorage;
+    /** Model registry for passing to subagents (avoids re-discovery) */
+    modelRegistry?: import("../config/model-registry").ModelRegistry;
+    /** Agent output manager for unique agent:// IDs across task invocations */
+    agentOutputManager?: AgentOutputManager;
+    /** Settings instance for passing to subagents */
+    settings: Settings;
+    /** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
+    serviceTier?: ServiceTier;
+    /** Plan mode state (if active) */
+    getPlanModeState?: () => PlanModeState | undefined;
+    /** Goal mode state (if active or paused) */
+    getGoalModeState?: () => GoalModeState | undefined;
+    /** SDK workflow-gate emitter, when a remote gate responder is connected. */
+    getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
+    /**
+     * Optional SDK-routed answer source for interactive asks. When present, the
+     * tool races the local UI selection against the remote SDK answer.
+     * No-op when undefined: the ask path behaves exactly as before.
+     */
+    getAskAnswerSource?: () => AskAnswerSource | undefined;
+    /** Optional per-session restriction for goal tool operations. */
+    goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
+    /** Goal runtime for the active agent session. */
+    getGoalRuntime?: () => GoalRuntime | undefined;
+    /** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
+    getClientBridge?: () => ClientBridge | undefined;
+    /** Get compact conversation context for subagents (excludes tool results, system prompts) */
+    getCompactContext?: () => string;
+    /** Get cached todo phases for this session. */
+    getTodoPhases?: () => TodoPhase[];
+    /** Replace cached todo phases for this session. */
+    setTodoPhases?: (phases: TodoPhase[]) => void;
+    /** Whether any form of tool discovery is active (tools.discoveryMode !== "off" or mcp.discoveryMode). */
+    isToolDiscoveryEnabled?: () => boolean;
+    /** Get all hidden-but-discoverable tools for search_tool_bm25 prompts. */
+    getDiscoverableTools?: (filter?: {
+        source?: import("../tool-discovery/tool-index").DiscoverableToolSource;
+    }) => DiscoverableTool[];
+    /** Get the cached generic discoverable search index. */
+    getDiscoverableToolSearchIndex?: () => DiscoverableToolSearchIndex;
+    /** Get tool names activated by prior search_tool_bm25 calls (all sources). */
+    getSelectedDiscoveredToolNames?: () => string[];
+    /** Merge tool selections into the active session tool set. */
+    activateDiscoveredTools?: (toolNames: string[]) => Promise<string[]>;
+    /** The tool-choice queue used to force forthcoming tool invocations and carry invocation handlers. */
+    getToolChoiceQueue?(): ToolChoiceQueue;
+    /** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
+    buildToolChoice?(toolName: string): ToolChoice | undefined;
+    /** Build a named tool-choice decision, preserving whether exact named forcing survived capability degradation. */
+    buildToolChoiceResult?(toolName: string): import("../utils/tool-choice").NamedToolChoiceResult;
+    /** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
+    steer?(message: {
+        customType: string;
+        content: string;
+        details?: unknown;
+    }): void;
+    /** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
+    peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
+     *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
+     *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */
+    peekStandingResolveHandler?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Register or clear the standing resolve handler. Passing `null` clears it. */
+    setStandingResolveHandler?(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
+    /** Get active checkpoint state if any. */
+    getCheckpointState?: () => CheckpointState | undefined;
+    /** Set or clear active checkpoint state. */
+    setCheckpointState?: (state: CheckpointState | null) => void;
+    /** Per-session cache of file contents as last shown to the model by
+     *  `read`/`search`. Used by hashline anchor-stale recovery to reconstruct
+     *  the version the model authored anchors against when the file changed
+     *  out-of-band. Lazily initialized by `getFileReadCache`. */
+    fileReadCache?: import("../edit/file-read-cache").FileReadCache;
+    /** Per-session log of unresolved git merge conflict regions surfaced by
+     *  `read`. Each entry gets a stable id N referenced by `write conflict://N`
+     *  to splice the recorded region with replacement content. Lazily initialized
+     *  by `getConflictHistory`. */
+    conflictHistory?: import("./conflict-detect").ConflictHistory;
+    /** Queue a hidden message to be injected at the next agent turn. */
+    queueDeferredMessage?(message: CustomMessage): void;
+    /** Dispatch a custom message through the active session. Used by the `skill`
+     *  tool to dispatch another skill prompt same-turn after recording a handoff. */
+    sendCustomMessage?(message: Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">, options?: {
+        triggerTurn?: boolean;
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+    }): Promise<void>;
+    /** Get the active OpenTelemetry config so subagent dispatch can forward
+     *  the parent's tracer/hooks with the subagent's own identity stamped. */
+    getTelemetry?: () => AgentTelemetryConfig | undefined;
+    /** Build a sanitized fork-context seed for task subagents. */
+    buildForkContextSeed?: (options: ForkContextSeedOptions) => Promise<ForkContextSeed>;
+}
+export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
+export type BuiltinToolLoadMode = "essential" | "discoverable";
+/** Default essential tool names when tools.essentialOverride is empty. */
+export declare const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[];
+/**
+ * Resolve the active essential built-in tool names from settings.
+ * Returns `tools.essentialOverride` if non-empty (filtered to known built-ins),
+ * otherwise `DEFAULT_ESSENTIAL_TOOL_NAMES`.
+ */
+export declare function computeEssentialBuiltinNames(settings: Settings): string[];
+/**
+ * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
+ * `BUILTIN_TOOLS[name](session)` to construct a public coding-harness tool directly.
+ *
+ * Hindsight memory helpers are intentionally excluded: memory is a private backend
+ * integration, not a public sayknow-cli tool surface.
+ */
+export interface BuiltinCapabilityCatalogEntry {
+    name: string;
+    label: string;
+    summary: string;
+    docsPath: string;
+    callableBuiltin: boolean;
+    defaultEnabled: boolean;
+}
+export declare const BUILTIN_CAPABILITY_CATALOG: readonly BuiltinCapabilityCatalogEntry[];
+export declare const BUILTIN_TOOLS: Record<string, ToolFactory>;
+export declare const HIDDEN_TOOLS: Record<string, ToolFactory>;
+export type ToolName = keyof typeof BUILTIN_TOOLS;
+export interface EvalBackendsAllowance {
+    python: boolean;
+    js: boolean;
+}
+/**
+ * Parse the `SKC_PY` multi-value token into per-backend booleans.
+ *
+ * Tokens (case-insensitive):
+ * - `0` / `bash` → JavaScript only (`{ py: false, js: true }`)
+ * - `1` / `py`   → Python only (`{ py: true, js: false }`)
+ * - `js`         → JavaScript only (`{ py: false, js: true }`)
+ * - `mix` / `both` → both backends (`{ py: true, js: true }`)
+ *
+ * Returns `null` when `SKC_PY` is unset, empty, or holds an unrecognized
+ * token, so the caller can fall back to the legacy `PI_PY` / `PI_JS` flags or
+ * per-key settings. This matches the documented contract that invalid values
+ * are ignored.
+ */
+export declare function parseSkcPy(env: Record<string, string | undefined>): {
+    py: boolean;
+    js: boolean;
+} | null;
+/**
+ * Resolve eval-backend allowance from environment only. `SKC_PY` wins when set
+ * to a recognized token; otherwise the legacy `PI_PY` / `PI_JS` flags apply.
+ * Returns `null` when no env override is set so the caller can defer to settings.
+ */
+export declare function resolveEvalBackendsFromEnv(env: Record<string, string | undefined>): EvalBackendsAllowance | null;
+/** Read per-backend allowance from settings (defaults true). */
+export declare function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance;
+/**
+ * Materialize the active eval backend allowance. `SKC_PY` takes precedence
+ * over the legacy `PI_PY` / `PI_JS` env flags, which in turn override the
+ * per-key settings (defaults true). When no env override is set, settings win.
+ */
+export declare function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance;
+export { resolvePythonIntegrationGate, resolvePythonIpcTrace, resolvePythonSkipCheck, } from "../eval/py/env";
+/**
+ * Create tools from BUILTIN_TOOLS registry.
+ */
+export declare function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]>;

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

@@ -0,0 +1,79 @@
+/**
+ * IRC tool — agent-to-agent messaging.
+ *
+ * Lets any live agent send a short prose message to any other live agent in
+ * this process and (optionally) get a prose reply.
+ *
+ * Routing happens via the global AgentRegistry. Replies are produced by an
+ * ephemeral side-channel call (`AgentSession.respondAsBackground`) that
+ * mirrors `/btw`: the recipient's current model, system prompt, and message
+ * history are used to compute a reply without persisting it through the
+ * normal stream path. After the reply is generated, both the incoming
+ * message and the auto-reply are queued for injection into the recipient's
+ * persisted history (deferred until the recipient is idle), so the model
+ * sees the exchange on its next turn.
+ *
+ * This avoids the deadlock that arises when the recipient is blocked on a
+ * long-running tool call: the side-channel call does not depend on the
+ * recipient's main agent loop being free.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const ircSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        list: "list";
+        send: "send";
+    }>;
+    to: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    awaitReply: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type IrcParams = z.infer<typeof ircSchema>;
+interface IrcReply {
+    from: string;
+    text: string;
+}
+export interface IrcDetails {
+    op: "send" | "list";
+    from?: string;
+    to?: string;
+    delivered?: string[];
+    replies?: IrcReply[];
+    failed?: Array<{
+        id: string;
+        error: string;
+    }>;
+    notFound?: string[];
+    peers?: Array<{
+        id: string;
+        displayName: string;
+        kind: string;
+        status: string;
+        parentId?: string;
+    }>;
+    channels?: string[];
+}
+export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
+    #private;
+    private readonly session;
+    readonly name = "irc";
+    readonly label = "IRC";
+    readonly summary = "Send and receive messages between agents over IRC-like channels";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodEnum<{
+            list: "list";
+            send: "send";
+        }>;
+        to: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        awaitReply: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): IrcTool | null;
+    execute(_toolCallId: string, params: IrcParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<IrcDetails>, _context?: AgentToolContext): Promise<AgentToolResult<IrcDetails>>;
+}
+export {};

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

@@ -0,0 +1,78 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import { type AsyncJob } from "../async";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from "./index";
+declare const jobSchema: z.ZodObject<{
+    poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    list: z.ZodOptional<z.ZodBoolean>;
+    tail: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type JobParams = z.infer<typeof jobSchema>;
+interface JobSnapshot {
+    id: string;
+    type: "bash" | "task";
+    status: "running" | "completed" | "failed" | "cancelled";
+    label: string;
+    durationMs: number;
+    resultText?: string;
+    errorText?: string;
+}
+type CancelStatus = "cancelled" | "not_found" | "already_completed" | "already_cancelled";
+export interface JobOutputTail {
+    id: string;
+    status: AsyncJob["status"];
+    text: string;
+    startOffset: number;
+    nextOffset: number;
+    truncated: boolean;
+}
+export interface JobToolDetails {
+    jobs: JobSnapshot[];
+    cancelled?: {
+        id: string;
+        status: CancelStatus;
+    }[];
+    output?: JobOutputTail[];
+}
+export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "job";
+    readonly label = "Job";
+    readonly summary = "Manage long-running background jobs (async bash/python)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        list: z.ZodOptional<z.ZodBoolean>;
+        tail: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): JobTool | null;
+    execute(_toolCallId: string, params: JobParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<JobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<JobToolDetails>>;
+}
+interface JobRenderArgs {
+    poll?: string[];
+    cancel?: string[];
+    tail?: string[];
+}
+export declare const jobToolRenderer: {
+    inline: boolean;
+    renderCall(args: JobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: JobToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: JobRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/json-tree.d.ts

@@ -0,0 +1,23 @@
+import type { Theme } from "../modes/theme/theme";
+/** Max depth for JSON tree rendering */
+export declare const JSON_TREE_MAX_DEPTH_COLLAPSED = 2;
+export declare const JSON_TREE_MAX_DEPTH_EXPANDED = 6;
+export declare const JSON_TREE_MAX_LINES_COLLAPSED = 6;
+export declare const JSON_TREE_MAX_LINES_EXPANDED = 200;
+export declare const JSON_TREE_SCALAR_LEN_COLLAPSED = 60;
+export declare const JSON_TREE_SCALAR_LEN_EXPANDED = 2000;
+/**
+ * Format a scalar value for inline display.
+ */
+export declare function formatScalar(value: unknown, maxLen: number): string;
+/**
+ * Format args inline for collapsed view.
+ */
+export declare function formatArgsInline(args: Record<string, unknown>, maxWidth: number): string;
+/**
+ * Render a JSON value as tree lines.
+ */
+export declare function renderJsonTreeLines(value: unknown, theme: Theme, maxDepth: number, maxLines: number, maxScalarLen: number): {
+    lines: string[];
+    truncated: boolean;
+};

package/dist/types/tools/jtd-to-json-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Convert JSON Type Definition (JTD) to JSON Schema.
+ *
+ * JTD (RFC 8927) is a simpler schema format. This converter allows users to
+ * write schemas in JTD and have them converted to JSON Schema for model APIs.
+ *
+ * @see https://jsontypedef.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc8927
+ */
+/**
+ * Detect if a schema is JTD format (vs JSON Schema).
+ *
+ * JTD schemas use: type (primitives), properties, optionalProperties, elements, values, enum, discriminator, ref
+ * JSON Schema uses: type: "object", type: "array", items, additionalProperties, etc.
+ */
+export declare function isJTDSchema(schema: unknown): boolean;
+/**
+ * Convert JTD schema to JSON Schema.
+ * If already JSON Schema, returns as-is.
+ */
+export declare function jtdToJsonSchema(schema: unknown): unknown;
+/**
+ * Normalize a schema input that may be a JSON string, object, or null/undefined.
+ * Returns { normalized } on success, or { error } if JSON parsing fails.
+ */
+export declare function normalizeSchema(schema: unknown): {
+    normalized?: unknown;
+    error?: string;
+};

package/dist/types/tools/jtd-to-typescript.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Convert JSON Type Definition (JTD) to TypeScript interface notation.
+ *
+ * Produces human-readable TypeScript for embedding in system prompts,
+ * helping models understand expected output structure.
+ */
+/**
+ * Convert JTD schema to TypeScript interface string.
+ *
+ * @example
+ * ```ts
+ * const schema = {
+ *   properties: {
+ *     name: { type: "string" },
+ *     count: { type: "int32" }
+ *   }
+ * };
+ * jtdToTypeScript(schema);
+ * // Returns:
+ * // {
+ * //   name: string;
+ * //   count: number;
+ * // }
+ * ```
+ */
+export declare function jtdToTypeScript(schema: unknown): string;

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

@@ -0,0 +1,42 @@
+/**
+ * JSON Type Definition (JTD) utility types and guards.
+ *
+ * Shared type definitions and type guard functions for JTD schema validation.
+ *
+ * @see https://jsontypedef.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc8927
+ */
+export type JTDPrimitive = "boolean" | "string" | "timestamp" | "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
+export interface JTDType {
+    type: JTDPrimitive;
+}
+export interface JTDEnum {
+    enum: string[];
+}
+export interface JTDElements {
+    elements: JTDSchema;
+}
+export interface JTDValues {
+    values: JTDSchema;
+}
+export interface JTDProperties {
+    properties?: Record<string, JTDSchema>;
+    optionalProperties?: Record<string, JTDSchema>;
+}
+export interface JTDDiscriminator {
+    discriminator: string;
+    mapping: Record<string, JTDProperties>;
+}
+export interface JTDRef {
+    ref: string;
+}
+export interface JTDEmpty {
+}
+export type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | JTDEmpty;
+export declare function isJTDType(schema: unknown): schema is JTDType;
+export declare function isJTDEnum(schema: unknown): schema is JTDEnum;
+export declare function isJTDElements(schema: unknown): schema is JTDElements;
+export declare function isJTDValues(schema: unknown): schema is JTDValues;
+export declare function isJTDProperties(schema: unknown): schema is JTDProperties;
+export declare function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator;
+export declare function isJTDRef(schema: unknown): schema is JTDRef;