@rho-workspace/rho 0.5.2 → 0.5.3

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/file-edit.d.ts

@@ -1,46 +0,0 @@
-import type { FileWriteInput } from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
-import type { ToolReporter, ToolResultContext, ToolResultFacts, ToolUseContext, ToolUseFacts } from "../facts.js";
-/**
- * Write: the diff holds the file text. The PostToolUse hook sends the final
- * diff, so the result text is only a confirmation.
- */
-export declare class WriteReporter implements ToolReporter {
-    toolUse(input: unknown, { cwd, capabilities, replay }: ToolUseContext): ToolUseFacts;
-    toolResult(): ToolResultFacts;
-    hookResult(toolResponse: unknown, context: ToolUseContext): Promise<ToolResultFacts>;
-}
-/** A Write input with the canonical keys, and the input key that holds the file text. */
-type NormalizedWriteInput = Partial<FileWriteInput> & {
-    contentKey?: string;
-};
-/**
- * Reads a Write input the way the CLI validates it. Since CLI 2.1.280 the CLI
- * accepts `path` for `file_path`, and `file_text` or `file_content` for
- * `content`. The streamed tool use keeps the original keys. The canonical key
- * wins when both spellings are present.
- */
-export declare function normalizeWriteInput(input: unknown): NormalizedWriteInput | undefined;
-/** Edit: the diff holds the old and the new text. */
-export declare class EditReporter implements ToolReporter {
-    toolUse(input: unknown, { cwd, capabilities }: ToolUseContext): ToolUseFacts;
-    toolResult(): ToolResultFacts;
-    hookResult(toolResponse: unknown, context: ToolUseContext): Promise<ToolResultFacts>;
-}
-/**
- * NotebookEdit: the new cell source is input. ACP has no notebook diff, and a
- * `diff` block would name the `.ipynb` file with cell text instead of file
- * text, so the source stays in `rawInput` and gets a display copy.
- *
- * Only AIR gets this rendering. Every other client gets the generic rendering
- * of the upstream adapter.
- */
-export declare class NotebookEditReporter implements ToolReporter {
-    toolUse(input: unknown, { cwd, capabilities }: ToolUseContext): ToolUseFacts;
-    /**
-     * The result text repeats the new cell source, which the input holds. A
-     * cell deletion has no source, so its result text is the result to show.
-     */
-    toolResult(context: ToolResultContext): ToolResultFacts;
-}
-export {};
-//# sourceMappingURL=file-edit.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/file-edit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-edit.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/file-edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,6CAA6C,CAAC;AAQrD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,GAAG,YAAY;IAoCpF,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAED,yFAAyF;AACzF,KAAK,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAI9E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAYpF;AAED,qDAAqD;AACrD,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IA0B5E,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAyCD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IAsB5E;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe;CAMxD"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/index.d.ts

@@ -1,4 +0,0 @@
-import type { ToolReporter } from "../facts.js";
-/** The reporter of a tool. MCP tools and unknown tools get the generic reporter. */
-export declare function reporterFor(toolName: string): ToolReporter;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgDhD,oFAAoF;AACpF,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAE1D"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/interaction.d.ts

@@ -1,86 +0,0 @@
-import type { ToolReporter, ToolResultContext, ToolResultFacts, ToolUseContext, ToolUseFacts } from "../facts.js";
-/**
- * ExitPlanMode: the plan is input that the user approves.
- *
- * Claude writes the plan to a file under `plansDirectory` while it drafts it.
- * The CLI adds the file text as `plan` and the file path as `planFilePath` to
- * the complete input. A `planFile` client gets the path and reads the plan
- * from the file. Without the file, it gets the plan text like other clients.
- */
-export declare class ExitPlanModeReporter implements ToolReporter {
-    toolUse(input: unknown, { capabilities }: ToolUseContext): ToolUseFacts;
-    /** The approval text repeats the plan, which the input holds. */
-    toolResult(context: ToolResultContext): ToolResultFacts;
-    /**
-     * The rejection reason has no display form. Claude fences it, so unfence it.
-     * A client that is not AIR gets the error text as the result to show.
-     */
-    errorResult(context: ToolResultContext): ToolResultFacts | undefined;
-}
-/** AskUserQuestion: the questions are input that the user reads. */
-export declare class AskUserQuestionReporter implements ToolReporter {
-    /**
-     * AIR gets a fixed title, because the question is input. Every other client
-     * gets the question of a single question as the title, like upstream.
-     */
-    toolUse(input: unknown, { capabilities }: ToolUseContext): ToolUseFacts;
-}
-/** Skill: the skill name is the label. The result is a confirmation. */
-export declare class SkillReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-    toolResult(): ToolResultFacts;
-}
-/**
- * TodoWrite and the Task* tools. The stream reports them as a plan. Only a
- * permission request surfaces them as a tool call.
- */
-export declare class PlanToolReporter implements ToolReporter {
-    private readonly toolName;
-    constructor(toolName: string);
-    toolUse(input: unknown): ToolUseFacts;
-}
-/** ReportFindings: the findings are input that the user reads. */
-export declare class ReportFindingsReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-}
-/** Every other tool, MCP tools too: the result text is the result to show. */
-export declare class GenericReporter implements ToolReporter {
-    private readonly toolName;
-    constructor(toolName: string);
-    toolUse(input: unknown): ToolUseFacts;
-}
-/**
- * An agent control tool (SendMessage, TaskStop, ListAgents, Monitor). AIR
- * shows the result in its own frame and parses the JSON result of SendMessage
- * and TaskStop. So AIR gets the error text as plain text, without a fence.
- * A client that is not AIR gets the fenced error text.
- */
-export declare class AgentControlReporter extends GenericReporter {
-    errorResult({ result, capabilities }: ToolResultContext): ToolResultFacts | undefined;
-}
-/**
- * The container scans of one resolution, so that a list of commands lists each container once.
- *
- * A list of slash commands is resolved in one synchronous pass, and nothing on disk changes within it. The cache
- * therefore lives exactly as long as that pass: every later pass sees the directories as they are.
- */
-export type SkillScanCache = Map<string, Map<string, string>>;
-/**
- * Absolute path of a skill's `SKILL.md`, or `undefined` when none of the known layouts holds one.
- *
- * The `Skill` tool reports only the skill's name, so the file has to be located by probing the layouts skills
- * actually use: project- and user-level `.claude/skills` (plus this repo's `.agents/skills` source of truth), and
- * for a `<prefix>:<name>` spelling either a plugin or a directory-scoped skill (`<prefix>/.claude/skills/<name>`),
- * which share that spelling. Only a path that exists on disk is returned, so a wrong guess costs nothing and
- * clients never render a link to a missing file.
- *
- * Claude Code advertises a skill by the `name:` of its frontmatter, which can differ from the name of the
- * directory, or of the symlink, that holds the file. A directory that carries the name therefore counts only
- * while the file in it declares that name or declares none; otherwise the same containers are scanned, in the
- * same order, for the `SKILL.md` that does declare it.
- *
- * [scans] holds the container listings of one resolution pass. Pass the same cache for every command of one
- * list, and each container is listed once instead of once per command.
- */
-export declare function resolveSkillPath(skillName: string, cwd?: string, scans?: SkillScanCache): string | undefined;
-//# sourceMappingURL=interaction.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/interaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/interaction.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IAYvE,iEAAiE;IACjE,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe;IASvD;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe,GAAG,SAAS;CASrE;AAqBD,oEAAoE;AACpE,qBAAa,uBAAwB,YAAW,YAAY;IAC1D;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;CAgBxE;AAED,wEAAwE;AACxE,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;IAKrC,UAAU,IAAI,eAAe;CAG9B;AAED;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,MAAM;IAE7C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAyBtC;AAED,kEAAkE;AAClE,qBAAa,sBAAuB,YAAW,YAAY;IACzD,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAmBtC;AAED,8EAA8E;AAC9E,qBAAa,eAAgB,YAAW,YAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,MAAM;IAE7C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAgBtC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;IACvD,WAAW,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,iBAAiB,GAAG,eAAe,GAAG,SAAS;CAGtF;AA4HD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AA0C9D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,cAAc,GACrB,MAAM,GAAG,SAAS,CA8EpB"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/read.d.ts

@@ -1,7 +0,0 @@
-import type { ToolReporter, ToolResultContext, ToolResultFacts, ToolUseContext, ToolUseFacts } from "../facts.js";
-/** Read: the file text is the result to show. */
-export declare class ReadReporter implements ToolReporter {
-    toolUse(input: unknown, { cwd }: ToolUseContext): ToolUseFacts;
-    toolResult({ toolUse, result, structured }: ToolResultContext): ToolResultFacts;
-}
-//# sourceMappingURL=read.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/read.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/read.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,iDAAiD;AACjD,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,EAAE,cAAc,GAAG,YAAY;IAgB9D,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,iBAAiB,GAAG,eAAe;CAiDhF"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/search.d.ts

@@ -1,16 +0,0 @@
-import type { ToolReporter, ToolUseFacts } from "../facts.js";
-/** Glob: the file list is the result to show. */
-export declare class GlobReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-}
-/** Grep: the title is the equivalent grep command line. */
-export declare class GrepReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-}
-/**
- * Reads a Grep input's path the way the CLI validates it. Since CLI 2.1.292
- * the CLI accepts `file_path` for `path`. The streamed tool use keeps the
- * original key. The canonical key wins when both spellings are present.
- */
-export declare function grepPath(input: unknown): string | undefined;
-//# sourceMappingURL=search.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE9D,iDAAiD;AACjD,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAWtC;AAED,2DAA2D;AAC3D,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAoBtC;AAgBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAK3D"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/web.d.ts

@@ -1,11 +0,0 @@
-import type { ToolReporter, ToolResultContext, ToolResultFacts, ToolUseFacts } from "../facts.js";
-/** WebFetch: the prompt is input that the user reads. The answer is the result. */
-export declare class WebFetchReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-}
-/** WebSearch: the hits are the result to show. */
-export declare class WebSearchReporter implements ToolReporter {
-    toolUse(input: unknown): ToolUseFacts;
-    toolResult({ result, structured }: ToolResultContext): ToolResultFacts;
-}
-//# sourceMappingURL=web.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-calls/reporters/web.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/web.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAElG,mFAAmF;AACnF,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;CAUtC;AAED,kDAAkD;AAClD,qBAAa,iBAAkB,YAAW,YAAY;IACpD,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;IAQrC,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,iBAAiB,GAAG,eAAe;CAuBvE"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-result-meta.d.ts

@@ -1,15 +0,0 @@
-export type ToolResultMeta = {
-    nonExecutionKind: string;
-    userFeedback?: string;
-};
-/**
- * Whether Claude Code stamped the result because the tool's run was aborted:
- * `interrupted` when the turn was interrupted, `cancelled` when the call's own
- * run was stopped, for example as it moved to the background. The other kinds
- * (`user-rejected`, `permission-rule`, `automode-*`) mean the tool was refused.
- */
-export declare function isAbortedToolResult(meta: ToolResultMeta | undefined): boolean;
-/** Validate the SDK's currently untyped tool_result_meta sidecar. Unknown
- * non-execution kinds are preserved so newer CLIs remain forward-compatible. */
-export declare function parseToolResultMeta(raw: unknown): Map<string, ToolResultMeta> | undefined;
-//# sourceMappingURL=tool-result-meta.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tool-result-meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-result-meta.d.ts","sourceRoot":"","sources":["../src/tool-result-meta.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAE7E;AAED;gFACgF;AAChF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,SAAS,CAczF"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tools.d.ts

@@ -1,93 +0,0 @@
-import type { PlanEntry, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk/unstable";
-import { HookCallback } from "@anthropic-ai/claude-agent-sdk";
-import type { TaskCreateInput, TaskCreateOutput, TaskListOutput, TaskUpdateInput, TaskUpdateOutput } from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
-import type { ToolResultBlock } from "./tool-calls/content.js";
-import { type RenderedResult } from "./tool-calls/renderer.js";
-export { markdownEscape, toDisplayPath } from "./tool-calls/content.js";
-/**
- * The title, kind, content, and locations of a tool use, for a client with the
- * given terminal and patch capabilities. The {@link AcpToolCallRenderer} builds
- * them from the facts of the tool reporter.
- */
-export declare function toolInfoFromToolUse(toolUse: any, supportsTerminalOutput?: boolean, cwd?: string, supportsDiffPatch?: boolean): {
-    title: string;
-    kind: ToolKind;
-    content: ToolCallContent[];
-    locations?: ToolCallLocation[];
-};
-/**
- * The result fields of a tool result, for a client with the given terminal
- * capabilities. The {@link AcpToolCallRenderer} builds them from the facts of
- * the tool reporter.
- */
-export declare function toolUpdateFromToolResult(toolResult: ToolResultBlock, toolUse: any | undefined, supportsTerminalOutput?: boolean, toolUseResult?: unknown, preferTerminalOutputDelta?: boolean): RenderedResult;
-export type ClaudePlanEntry = {
-    content: string;
-    status: "pending" | "in_progress" | "completed";
-    activeForm: string;
-};
-export declare function planEntries(input: {
-    todos: ClaudePlanEntry[];
-} | undefined): PlanEntry[];
-/**
- * Per-session task list accumulated from Task* tool calls (TaskCreate /
- * TaskUpdate). The headless/SDK session emits these as incremental tool
- * calls keyed by task ID, replacing the snapshot-style TodoWrite tool.
- * Iteration order is insertion order (Map semantics), matching the order
- * tasks are created.
- */
-export type TaskEntry = {
-    subject: string;
-    status: "pending" | "in_progress" | "completed";
-    activeForm?: string;
-    description?: string;
-};
-export type TaskState = Map<string, TaskEntry>;
-export declare function parseTaskCreateOutput(content: unknown): TaskCreateOutput | undefined;
-export declare function parseTaskListOutput(content: unknown): TaskListOutput | undefined;
-export declare function parseTaskUpdateOutput(content: unknown, expectedTaskId?: string): TaskUpdateOutput | undefined;
-export declare function applyTaskCreate(state: TaskState, input: TaskCreateInput | undefined, output: TaskCreateOutput | undefined): void;
-export declare function applyTaskUpdate(state: TaskState, input: TaskUpdateInput | undefined): void;
-export declare function applyTaskList(state: TaskState, output: TaskListOutput): void;
-export declare function taskStateToPlanEntries(state: TaskState): PlanEntry[];
-/**
- * The plan entries of the task list, or undefined when the client already
- * holds the same entries. The TaskCreated and TaskCompleted hooks and the
- * Task* tool results report the same change, so the second report of a
- * change has nothing new.
- *
- * Only an AIR client skips the repeated plan. Every other client gets every
- * plan, like upstream.
- */
-export declare function changedTaskPlanEntries(state: TaskState, airClient: boolean): PlanEntry[] | undefined;
-/** Forgets the plan that the client holds, so that the next plan goes out, for example on replay. */
-export declare function forgetPublishedTaskPlan(state: TaskState): void;
-export declare const registerHookCallback: (toolUseID: string, { onPostToolUseHook, onRelease, }: {
-    onPostToolUseHook?: (toolUseID: string, toolInput: unknown, toolResponse: unknown) => Promise<void>;
-    onRelease?: () => void;
-}, ownerId?: string) => void;
-export declare function unregisterHookCallback(toolUseID: string): void;
-/** Whether a PostToolUse callback for the tool use is still registered. */
-export declare function hasHookCallback(toolUseID: string): boolean;
-/** PostToolUse normally follows tool_result, so keep the callback for a short
- * grace period while still bounding retention when the hook never arrives. */
-export declare function completeHookCallback(toolUseID: string): void;
-export declare function clearHookCallbacks(ownerId: string): void;
-export declare const createPostToolUseHook: (options?: {
-    onEnterPlanMode?: () => Promise<void>;
-}) => HookCallback;
-/**
- * Hook callback for `TaskCreated` / `TaskCompleted` events. The SDK fires
- * these for both user-facing TaskCreate tool calls and subagent task
- * creation, giving us `task_id` + `task_subject` without having to parse
- * tool_result payloads.
- *
- * Populating `taskState` from the hook means a later `TaskUpdate` (which
- * typically only carries `taskId` + `status`) finds an existing entry with
- * a real subject, instead of synthesizing a placeholder with empty content.
- */
-export declare const createTaskHook: (options: {
-    taskState: TaskState;
-    onChange?: () => Promise<void>;
-}) => HookCallback;
-//# sourceMappingURL=tools.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/turn-events.d.ts

@@ -1,97 +0,0 @@
-/**
- * A prompt turn and the foreground work of a session, as the adapter
- * understands them, independent of the ACP version.
- *
- * The agent reports how each prompt is answered through {@link TurnEvents}:
- * ACP v1 answers `session/prompt` when the turn ends or fails, and ACP v2 when
- * the prompt is inserted. ACP v2 also reports the session's work as state,
- * which the agent reports through {@link ForegroundEvents}.
- *
- * The agent calls these synchronously while it updates its own state, so a
- * handler must not throw, nor call back into the agent before it returns.
- */
-export interface TurnEvents {
-    /**
-     * Claude Code took the prompt in as the user message `messageId` of the
-     * conversation. Reported at most once per turn, and never after
-     * {@link ended} or {@link failed}.
-     *
-     * When Claude Code reports command lifecycles (`msg_lifecycle_v1`), that is
-     * when the prompt starts a turn, before the turn's output. Otherwise, and
-     * while another turn is still active (held for its background work,
-     * steered, or cancelled but not yet ended), it is the prompt's echo, after
-     * that turn ended; for a command Claude Code does not echo (such as
-     * `/compact`), it is the command's result, after any output it streamed.
-     */
-    inserted(messageId: string): void;
-    /**
-     * The turn ended. A queued turn that is cancelled before it is inserted
-     * ends too, without {@link inserted}; Claude Code may still run its prompt.
-     */
-    ended(outcome: TurnOutcome): void;
-    /**
-     * The turn failed with `error`, the JSON-RPC error that v1 answers the
-     * prompt with. Without {@link inserted} before, Claude Code was not seen
-     * taking the prompt in.
-     */
-    failed(error: unknown): void;
-}
-/**
- * The foreground work of a session: what a client would wait for before it
- * sends the next prompt. One piece of work runs at a time, and the next starts
- * with {@link running}. The work is either:
- *
- * - A prompt's turn, from {@link TurnEvents.inserted} until its result, or
- *   until it fails or is cancelled. A turn that v1 holds open for the
- *   background subagents it spawned (`Turn.deferredSettle`) ends its work at
- *   its result all the same: the hold only delays v1's answer.
- * - A model cycle that Claude Code starts on its own while no work runs: for
- *   example, its follow-up after a background command or subagent finished,
- *   or its answer to a message from another session. It runs until its result.
- *
- * A prompt that Claude Code takes in while a cycle runs takes the cycle over:
- * the cycle reports nothing more, and the turn reports from there.
- */
-export interface ForegroundEvents {
-    /**
-     * The work started, or works again after it waited for the user. Not after
-     * a wait that a cancel ended: Claude Code's interrupt withdrew the last
-     * request, so the work is being stopped, and {@link ended} follows at once.
-     */
-    running(): void;
-    /**
-     * The work waits for the user: a permission request or a question is open in
-     * the session. Requests do not say which work they are for, so this includes
-     * one opened before the work started.
-     */
-    awaitingUser(): void;
-    /** The work ended. */
-    ended(outcome: TurnOutcome): void;
-    /**
-     * The work failed with `error`, the JSON-RPC error that v1 answers the
-     * prompt with.
-     */
-    failed(error: unknown): void;
-}
-/** Why a turn ended. Every ACP version has these reasons. */
-export type StopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
-/** How a turn ended. */
-export type TurnOutcome = {
-    stopReason: StopReason;
-    /** The tokens that the main agent loop of the turn used. */
-    usage?: TurnUsage;
-    /**
-     * Extension data for the client, such as the quota breakdown of the turn
-     * and a terminal session failure.
-     */
-    _meta?: Record<string, unknown>;
-};
-export type TurnUsage = {
-    totalTokens: number;
-    inputTokens: number;
-    outputTokens: number;
-    thoughtTokens?: number;
-    cachedReadTokens?: number;
-    cachedWriteTokens?: number;
-};
-//# sourceMappingURL=turn-events.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/turn-events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"turn-events.d.ts","sourceRoot":"","sources":["../src/turn-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,OAAO,IAAI,IAAI,CAAC;IAChB;;;;OAIG;IACH,YAAY,IAAI,IAAI,CAAC;IACrB,sBAAsB;IACtB,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B;AAED,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,mBAAmB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEnG,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/usage-markdown.d.ts

@@ -1,9 +0,0 @@
-import type { SDKControlGetUsageResponse } from "@anthropic-ai/claude-agent-sdk";
-/** Validate the experimental SDK response at the runtime boundary. */
-export declare function parseUsageResponse(value: unknown): SDKControlGetUsageResponse | null;
-export declare function isUsageCommandText(text: string): boolean;
-/** Escape the Markdown syntax characters of `value` and fold its line breaks. */
-export declare function escapeMarkdown(value: string): string;
-/** Render the SDK's structured `/usage` response as Markdown. */
-export declare function formatUsageResponse(usage: SDKControlGetUsageResponse): string;
-//# sourceMappingURL=usage-markdown.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/usage-markdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage-markdown.d.ts","sourceRoot":"","sources":["../src/usage-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAsEjF,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,GAAG,IAAI,CAMpF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AASD,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AA0ED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAiE7E"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/utils.d.ts

@@ -1,59 +0,0 @@
-import { Readable, Writable } from "node:stream";
-import { WritableStream, ReadableStream } from "node:stream/web";
-import { Logger } from "./acp-agent.js";
-export declare class Pushable<T> implements AsyncIterable<T> {
-    private queue;
-    private resolvers;
-    private done;
-    push(item: T): void;
-    end(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-export declare function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array>;
-export declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
-export declare function unreachable(value: never, logger?: Logger): void;
-/**
- * Yields to the event loop when the current macrotask has run for too long.
- *
- * An await of an already-resolved promise continues in a microtask, so a loop
- * that drains a backlog of buffered messages never lets timers or I/O run:
- * incoming requests, `session/cancel` among them, wait until the backlog is
- * gone. A loop calls {@link maybeYield} once per item. Within the budget it
- * returns undefined and the loop goes on at once. Past the budget it returns a
- * promise that resolves in the check phase of the event loop, after pending
- * I/O has run.
- *
- * The budget is measured from the first call since the event loop last
- * reached its check phase, so a loop that already waits on real I/O never
- * yields, and all loops that share one instance share one budget per
- * event-loop iteration.
- *
- * A test that fakes `setImmediate` and drives such a loop for longer than the
- * budget must advance the fake timers, or the loop waits for them.
- */
-export declare class EventLoopYielder {
-    private readonly budgetMs;
-    private readonly now;
-    /** Whether a check-phase marker is pending. While it is, the event loop has
-     *  not reached its check phase since {@link sliceStart}. */
-    private markerPending;
-    private sliceStart;
-    constructor(budgetMs: number, now?: () => number);
-    maybeYield(): Promise<void> | undefined;
-}
-/** The yielder shared by the loops that forward messages to the client. */
-export declare const messageLoopYielder: EventLoopYielder;
-export declare function sleep(time: number): Promise<void>;
-/** The outcome of {@link raceTimeoutAndAbort}. */
-export type RaceOutcome<T> = {
-    type: "done";
-    value: T;
-} | {
-    type: "timeout";
-} | {
-    type: "aborted";
-};
-/** Wait for `promise` until `timeoutMs` passes or `signal` aborts. A rejection
- *  of `promise` rejects the result. The timer does not keep the process alive. */
-export declare function raceTimeoutAndAbort<T>(promise: Promise<T>, timeoutMs: number, signal: AbortSignal): Promise<RaceOutcome<T>>;
-//# sourceMappingURL=utils.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAKD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAoBlF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAgB;IAOzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAPtB;gEAC4D;IAC5D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAK;gBAGJ,QAAQ,EAAE,MAAM,EAChB,GAAG,GAAE,MAAM,MAAgC;IAG9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;CAaxC;AAMD,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,kBAA+C,CAAC;AAE/E,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD;AAED,kDAAkD;AAClD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAEpG;kFACkF;AAClF,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAoBzB"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/agent.d.ts

@@ -1,13 +0,0 @@
-import * as v2 from "@agentclientprotocol/sdk/experimental/v2/unstable";
-import { ClaudeAcpAgent, type Logger } from "../acp-agent.js";
-/**
- * The ACP v2 surface, for one connection.
- *
- * As in `v1AgentApp`, the agent of the connection is created when the
- * connection opens, before the connection processes any inbound message.
- * `onAgent` receives it for the owner of the process (shutdown).
- *
- * The provider methods pass through: their types are the same in v1 and v2.
- */
-export declare function v2AgentApp(logger: Logger | undefined, onAgent: (agent: ClaudeAcpAgent) => void): v2.AgentApp;
-//# sourceMappingURL=agent.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/v2/agent.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,mDAAmD,CAAC;AACxE,OAAO,EAAE,cAAc,EAAkB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAoB9E;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,QAAQ,CAqFb"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/initialize.d.ts

@@ -1,21 +0,0 @@
-/**
- * The ACP v2 `initialize` handshake, expressed through the v1 handshake of
- * `ClaudeAcpAgent`.
- *
- * The agent decides its capabilities and auth methods in v1 terms. The v2
- * request becomes the v1 request that the agent reads, and the v1 response of
- * the agent becomes the v2 response, so both protocol versions advertise from
- * one source.
- */
-import { type InitializeRequest, type InitializeResponse } from "@agentclientprotocol/sdk/unstable";
-import * as v2 from "@agentclientprotocol/sdk/experimental/v2/unstable";
-/** The v1 `initialize` request that a v2 client means. */
-export declare function v1InitializeRequest(request: v2.InitializeRequest): InitializeRequest;
-/**
- * The v2 `initialize` response for the v1 response of the agent.
- *
- * It does not advertise what the v2 surface does not serve yet: the
- * extensions of {@link UNSERVED_EXTENSION_KEYS}.
- */
-export declare function v2InitializeResponse(response: InitializeResponse): v2.InitializeResponse;
-//# sourceMappingURL=initialize.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/initialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../src/v2/initialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,mDAAmD,CAAC;AAGxE,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,GAAG,iBAAiB,CAmCpF;AASD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,EAAE,CAAC,kBAAkB,CAuBxF"}

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/permission.d.ts

@@ -1,25 +0,0 @@
-/**
- * The v2 form of the permission requests that `ClaudeAcpAgent` sends, and the
- * v1 form of their answers.
- */
-import type { RequestPermissionResponse } from "@agentclientprotocol/sdk/unstable";
-import type * as v2 from "@agentclientprotocol/sdk/experimental/v2/unstable";
-import type { AcpPermissionRequest } from "../permissions/presentation.js";
-/**
- * The v2 form of a permission request of the agent.
- *
- * v1 asks about a tool call, whose title the prompt shows. v2 gives the prompt
- * its own `title` and `description`, which the agent sets for a v2 client
- * (`AcpPermissionRequest`), and asks about a `subject`: here always the tool
- * call, as the same patch that a `tool_call_update` carries.
- */
-export declare function v2PermissionRequest(request: AcpPermissionRequest): v2.RequestPermissionRequest;
-/**
- * The v1 form of the answer to a permission request.
- *
- * v2 adds outcomes that v1 does not know, which the draft says are no
- * approval. They become `cancelled`, which the agent reads as an aborted tool
- * use, as it does a cancelled prompt.
- */
-export declare function v1PermissionResponse(response: v2.RequestPermissionResponse): RequestPermissionResponse;
-//# sourceMappingURL=permission.d.ts.map

package/node_modules/@agentclientprotocol/claude-agent-acp/dist/v2/permission.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../src/v2/permission.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,KAAK,KAAK,EAAE,MAAM,mDAAmD,CAAC;AAC7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAG3E;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,EAAE,CAAC,wBAAwB,CAY9F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,EAAE,CAAC,yBAAyB,GACrC,yBAAyB,CAS3B"}