@nyte-ai/plugin 0.0.0-stage → 0.0.19

package/dist/src/acp/registry.d.ts

@@ -0,0 +1,18 @@
+/** An ACP agent this machine can start without downloading anything. */
+export interface AcpAgent {
+    readonly id: string;
+    readonly name: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+}
+/** The agent entries of a registry document; anything else is no entries. */
+export declare function registryEntries(document: unknown): readonly unknown[];
+/**
+ * The registry agents installed on this machine, in registry order: a binary
+ * agent whose command is on `path`, or an npx agent whose package is
+ * installed globally beside `npx` (its own bin, not another command of the
+ * same name), run with the registry's arguments. An agent only the registry
+ * can download is left out, so choosing a model never downloads one.
+ */
+export declare function installedAgents(entries: readonly unknown[], path: string): Promise<readonly AcpAgent[]>;

package/dist/src/acp/registry.js

@@ -0,0 +1,9 @@
+import {
+  registryEntries2,
+  installedAgents2
+} from "../../chunks/billing-hg64tqf1.js";
+import"../../chunks/billing-4vz9pxyx.js";
+export {
+  installedAgents2 as installedAgents,
+  registryEntries2 as registryEntries
+};

package/dist/src/acp/thread.d.ts

@@ -0,0 +1,46 @@
+import type { ContentBlock, PromptResponse, RequestPermissionRequest, RequestPermissionResponse, SessionUpdate } from "@agentclientprotocol/sdk";
+import type { Api, AssistantMessageEventStream, Model } from "@nyte-ai/ai";
+import type { RuntimeCall, RuntimeVerdict } from "@nyte-ai/core";
+/** Decides a call the agent asks permission for, under the session's policy. */
+export type AcpApprove = (call: RuntimeCall, signal: AbortSignal) => Promise<RuntimeVerdict>;
+/** What one of the agent's tool calls reported once it finished, or as far as it got when the turn ended. */
+export interface AcpToolOutput {
+    readonly text: string;
+    readonly failed: boolean;
+}
+/** How a thread reaches its agent: one prompt turn, the cancel notification for it, the folder its session runs in, and how a permission it asks for is decided. */
+export interface AcpChannel {
+    readonly cwd: string;
+    prompt(blocks: readonly ContentBlock[]): Promise<PromptResponse>;
+    cancel(): void;
+    readonly approve: AcpApprove;
+}
+/**
+ * One ACP session on an agent: the prompt turns Nyte sends it, the updates
+ * it streams back as assistant messages, and its tool calls, which Nyte
+ * records as mirror calls whose ids start with `prefix`. A permission the
+ * agent asks for waits until Nyte records that call, then goes to the
+ * channel's `approve` under the call's ACP kind; a call Nyte skips is
+ * refused.
+ */
+export declare class AcpThread {
+    #private;
+    readonly prefix: string;
+    constructor(prefix: string, channel: AcpChannel);
+    get closed(): boolean;
+    /** Sends a prompt turn, or queues it behind the turn the agent is running, since ACP takes no message mid-turn. */
+    send(blocks: readonly ContentBlock[]): void;
+    update(update: SessionUpdate): void;
+    permission(request: RequestPermissionRequest): Promise<RequestPermissionResponse>;
+    /** Lets the agent's permission ask for `id`, now or later, go on to its approval: Nyte is recording the call. */
+    recording(id: string): void;
+    /** Refuses `id` when the agent asks, now or later: Nyte settled it without running it. A call this thread never saw is left alone. */
+    skip(id: string): void;
+    /** Streams the turn as one assistant message, ending at the agent's next new tool call or at the turn's end; with `tools` false, its tool calls are refused and skipped. */
+    respond(model: Model<Api>, signal: AbortSignal | undefined, tools?: boolean): AssistantMessageEventStream;
+    /** Waits for the agent to finish tool call `id`: until it completes or fails, the turn ends, or the agent waits on another call's permission. */
+    result(id: string, signal: AbortSignal): Promise<AcpToolOutput>;
+    /** Stops the running turn: tells the agent, and answers its waiting permissions as cancelled. */
+    cancel(): void;
+    close(reason?: Error): void;
+}

package/dist/src/acp/thread.js

@@ -0,0 +1,7 @@
+import {
+  AcpThread2
+} from "../../chunks/billing-svrhh5a5.js";
+import"../../chunks/billing-9nn3yp18.js";
+export {
+  AcpThread2 as AcpThread
+};

package/dist/src/acp/transcript.d.ts

@@ -0,0 +1,8 @@
+import type { ContentBlock } from "@agentclientprotocol/sdk";
+import type { Message, UserMessage } from "@nyte-ai/ai";
+/** A message's identity for telling whether the agent's session already holds it. */
+export declare function messageKey(message: Message): string;
+/** A user message as prompt blocks; an image the agent cannot read becomes a note of its type. */
+export declare function userBlocks(message: UserMessage, images: boolean): ContentBlock[];
+/** The conversation as plain text, for an agent session that did not see it happen. */
+export declare function transcriptText(messages: readonly Message[]): string;

package/dist/src/acp/transcript.js

@@ -0,0 +1,11 @@
+import {
+  messageKey2,
+  userBlocks2,
+  transcriptText2
+} from "../../chunks/billing-wmcbg6fw.js";
+import"../../chunks/billing-9nn3yp18.js";
+export {
+  messageKey2 as messageKey,
+  transcriptText2 as transcriptText,
+  userBlocks2 as userBlocks
+};

package/dist/src/acp/translate.d.ts

@@ -0,0 +1,33 @@
+import type { ToolCallContent, Usage } from "@agentclientprotocol/sdk";
+import type { Api, AssistantMessage, AssistantMessageEventStream, Model, ToolCall } from "@nyte-ai/ai";
+import type { ToolClass } from "@nyte-ai/schema";
+import { Type } from "typebox";
+import type { Static } from "typebox";
+export declare const ACP_PROVIDER = "acp";
+export declare const ACP_API = "acp";
+export declare const MIRROR_TOOL = "acp";
+/** A mirror call's arguments: the ACP session it ran in, the agent's own call id, title, kind, input and the paths it touches. */
+export declare const mirrorArguments: Type.TObject<{
+    thread: Type.TString;
+    id: Type.TString;
+    title: Type.TString;
+    kind: Type.TString;
+    input: Type.TRecord<"^.*$", Type.TUnknown>;
+    paths: Type.TArray<Type.TString>;
+}>;
+export type MirrorArguments = Static<typeof mirrorArguments>;
+export declare function emptyMessage(model: Model<Api>): AssistantMessage;
+/** The class Nyte shows and gates an agent's tool call by, from the ACP kind, its paths and its input. */
+export declare function mirrorClass(args: MirrorArguments): ToolClass;
+/** What a finished agent tool call reports, as the text its mirror call returns. */
+export declare function toolText(content: readonly ToolCallContent[], rawOutput: unknown): string;
+/** Builds one assistant message from an agent's streamed text, thoughts and tool calls. */
+export declare class Translator {
+    #private;
+    constructor(model: Model<Api>, output: AssistantMessage, stream: AssistantMessageEventStream);
+    text(delta: string): void;
+    thinking(delta: string): void;
+    call(call: ToolCall): void;
+    usage(usage: Usage): void;
+    end(): void;
+}

package/dist/src/acp/translate.js

@@ -0,0 +1,20 @@
+import {
+  ACP_PROVIDER2,
+  ACP_API2,
+  MIRROR_TOOL2,
+  mirrorArguments2,
+  emptyMessage2,
+  mirrorClass2,
+  toolText2,
+  Translator2
+} from "../../chunks/billing-9nn3yp18.js";
+export {
+  ACP_API2 as ACP_API,
+  ACP_PROVIDER2 as ACP_PROVIDER,
+  MIRROR_TOOL2 as MIRROR_TOOL,
+  Translator2 as Translator,
+  emptyMessage2 as emptyMessage,
+  mirrorArguments2 as mirrorArguments,
+  mirrorClass2 as mirrorClass,
+  toolText2 as toolText
+};

package/dist/src/approvals/approvals.d.ts

@@ -0,0 +1,189 @@
+import type { PluginApi, RuntimeCall, RuntimeVerdict, SettingDefinition, ToolDefinition } from "@nyte-ai/core";
+import type { ApprovalPolicy, ApprovalState } from "./schema.ts";
+/** A tool call as the policy sees it: its tool's name, its class, and whether its tool lets a policy hold it. */
+export interface ApprovalTool extends RuntimeCall {
+    readonly approval?: ToolDefinition["approval"];
+}
+/**
+ * The host's policy for tool calls, `full` by default. It applies to every
+ * session at its next call, including one already running.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const permissions: SettingDefinition<ApprovalPolicy>;
+/**
+ * Why `policy` stops `tool` for the user in a workspace at `cwd`, or null
+ * when the call runs without asking. Reads, listings, delegation and tools
+ * whose `approval` is not `policy` never ask (a subagent's own calls ask in
+ * its session); under `auto-edit` an edit in the workspace runs unless it is
+ * under `.claude`, `.git` or `.nyte`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function approvalReason(policy: ApprovalPolicy, tool: ApprovalTool, cwd: string): ApprovalState["reason"] | null;
+/**
+ * The approval part with its handlers: the first answer is kept, and
+ * `session` records a grant for the tool and answers the session's other
+ * waiting approvals for it.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const approval: import("@nyte-ai/core").PartDefinition<{
+    class: {
+        kind: "read";
+        path: string;
+    } | {
+        kind: "list";
+        path: string;
+    } | {
+        kind: "edit";
+        path: string;
+    } | {
+        description?: string | undefined;
+        kind: "shell";
+        command: string;
+    } | {
+        kind: "delegate";
+        title: string | null;
+        role: "read" | "task" | "create" | "send" | "await" | "stop";
+        child: import("@nyte-ai/schema").Id<"session"> | null;
+    } | {
+        kind: "custom";
+        label: string;
+    };
+    reason: "edit" | "shell" | "tool" | "outside";
+    tool: string;
+    decision: "session" | "once" | "deny" | null;
+}, {
+    once: {
+        input: import("@nyte-ai/schema").Schema<object>;
+    };
+    session: {
+        input: import("@nyte-ai/schema").Schema<object>;
+    };
+    deny: {
+        input: import("@nyte-ai/schema").Schema<object>;
+    };
+}>;
+declare function approveRuntimeCall(call: RuntimeCall, context: {
+    readonly api: PluginApi<"core">;
+    readonly signal: AbortSignal;
+}): Promise<RuntimeVerdict>;
+/**
+ * Gates tool calls on the session's `permissions` policy, keying grants on
+ * each tool's own name. A call in Nyte's loop that asks parks its
+ * before_tool hook on an approval part, so the request outlives a host
+ * restart and any client watching the session can answer it; a denial
+ * reaches the model as the rejected call's reason. A call another agent
+ * runtime asks to run comes through `approve` and waits on the same part
+ * while its runtime runs; its mirror call (`approval: "runtime"`) is not
+ * asked about again. Only a principal with owner authority can allow.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        parts: import("@nyte-ai/core").PartDefinition<{
+            class: {
+                kind: "read";
+                path: string;
+            } | {
+                kind: "list";
+                path: string;
+            } | {
+                kind: "edit";
+                path: string;
+            } | {
+                description?: string | undefined;
+                kind: "shell";
+                command: string;
+            } | {
+                kind: "delegate";
+                title: string | null;
+                role: "read" | "task" | "create" | "send" | "await" | "stop";
+                child: import("@nyte-ai/schema").Id<"session"> | null;
+            } | {
+                kind: "custom";
+                label: string;
+            };
+            reason: "edit" | "shell" | "tool" | "outside";
+            tool: string;
+            decision: "session" | "once" | "deny" | null;
+        }, {
+            once: {
+                input: import("@nyte-ai/schema").Schema<object>;
+            };
+            session: {
+                input: import("@nyte-ai/schema").Schema<object>;
+            };
+            deny: {
+                input: import("@nyte-ai/schema").Schema<object>;
+            };
+        }>[];
+        settings: SettingDefinition<"ask" | "auto-edit" | "full">[];
+    };
+    approve: typeof approveRuntimeCall;
+    hooks: {
+        before_tool: (call: Readonly<{
+            readonly call: import("@nyte-ai/schema").Id<"call">;
+            readonly name: string;
+            readonly args: import("@nyte-ai/schema").Json;
+            readonly class: {
+                readonly kind: "read";
+                readonly path: string;
+            } | {
+                readonly kind: "list";
+                readonly path: string;
+            } | {
+                readonly kind: "edit";
+                readonly path: string;
+            } | {
+                readonly description?: string | undefined;
+                readonly kind: "shell";
+                readonly command: string;
+            } | {
+                readonly kind: "delegate";
+                readonly title: string | null;
+                readonly role: "read" | "task" | "create" | "send" | "await" | "stop";
+                readonly child: import("@nyte-ai/schema").Id<"session"> | null;
+            } | {
+                readonly kind: "custom";
+                readonly label: string;
+            };
+        }>, context: {
+            readonly api: {
+                readonly side: "core";
+                readonly sdk: import("@nyte-ai/core").Connection;
+                readonly contribute: import("@nyte-ai/core").Registries<"core">;
+                readonly storage: import("@nyte-ai/core").PluginStorage;
+                readonly signal: AbortSignal;
+                hook<N extends "session_activated" | "before_send" | "run_started" | "transform_transcript" | "before_compaction" | "before_request" | "before_tool" | "after_tool" | "after_request" | "run_ended">(name: N, entry: import("@nyte-ai/core").HookEntry<"core", N>): import("@nyte-ai/schema").Disposer;
+                report(issue: import("@nyte-ai/schema").ValidationIssue): void;
+                reload(): void;
+            } & {
+                readonly session: import("@nyte-ai/core").Session;
+                readonly env: import("@nyte-ai/core").ExecutionEnv;
+                wrapEnv(wrap: import("@nyte-ai/core").EnvironmentWrap): import("@nyte-ai/schema").Disposer;
+                readonly inputs: import("@nyte-ai/core").Resources;
+                request<T = string>(input: import("@nyte-ai/schema").ModelRequestInput<T>): Promise<import("@nyte-ai/schema").ModelRequestOutcome<T>>;
+                approve(call: RuntimeCall, signal: AbortSignal): Promise<RuntimeVerdict>;
+            };
+            readonly signal: AbortSignal;
+            readonly session: import("@nyte-ai/schema").SessionId | null;
+            readonly head: import("@nyte-ai/schema").HeadName | null;
+            readonly run: import("@nyte-ai/schema").RunId | null;
+        } & import("@nyte-ai/core").Durable) => Promise<{
+            action: "continue";
+            reason?: undefined;
+        } | {
+            action: "reject";
+            reason: string;
+        }>;
+    };
+};
+export default _default;

package/dist/src/approvals/approvals.js

@@ -0,0 +1,143 @@
+import {
+  PERMISSIONS2,
+  approvalPolicy2,
+  APPROVAL_POLICIES2,
+  approval2,
+  openApprovals2
+} from "../../chunks/billing-h13r0byk.js";
+
+// src/approvals/approvals.ts
+import { posix } from "node:path";
+import { definePart } from "@nyte-ai/core";
+import { SdkError } from "@nyte-ai/schema";
+var DENIED = "The user denied this tool call. Ask them how to proceed instead of retrying it.";
+var UNANSWERED = "The approval request closed before the user answered.";
+var permissions = {
+  id: PERMISSIONS2,
+  label: "Permissions",
+  schema: approvalPolicy2,
+  choices: APPROVAL_POLICIES2,
+  default: "full",
+  scope: "host"
+};
+var GUARDED = new Set([".claude", ".git", ".nyte"]);
+function grantKey(tool) {
+  return `grant:${tool}`;
+}
+function workspacePath(cwd, path) {
+  const root = posix.resolve(cwd);
+  const target = posix.resolve(root, path);
+  if (target === root)
+    return "";
+  return target.startsWith(`${root}/`) ? target.slice(root.length + 1) : null;
+}
+function approvalReason(policy, tool, cwd) {
+  const subject = tool.class;
+  if (policy === "full" || (tool.approval ?? "policy") !== "policy")
+    return null;
+  if (subject.kind === "read" || subject.kind === "list" || subject.kind === "delegate")
+    return null;
+  if (subject.kind === "shell")
+    return "shell";
+  if (subject.kind === "edit") {
+    const path = workspacePath(cwd, subject.path);
+    if (path === null)
+      return "outside";
+    return policy === "ask" || GUARDED.has(path.split("/", 1)[0] ?? "") ? "edit" : null;
+  }
+  return "tool";
+}
+async function readPolicy(api) {
+  const value = await api.contribute.settings.value(PERMISSIONS2);
+  const checked = approvalPolicy2["~standard"].validate(value);
+  return checked instanceof Promise || checked.issues !== undefined ? permissions.default : checked.value;
+}
+async function pendingReason(api, tool) {
+  const reason = approvalReason(await readPolicy(api), tool, api.env.cwd);
+  if (reason === null)
+    return null;
+  return await api.storage.get(grantKey(tool.name)) === true ? null : reason;
+}
+function verdict(action) {
+  if (action === "once" || action === "session")
+    return { kind: "allow" };
+  return { kind: "deny", reason: action === "deny" ? DENIED : UNANSWERED };
+}
+async function decide(decision, context) {
+  const allowed = decision === "deny" || context.authority.has("owner");
+  let granted = null;
+  let refused = false;
+  const outcome = await context.part.update((current) => {
+    refused = current.decision === null && !allowed;
+    granted = current.decision === null || current.decision === decision ? current.tool : null;
+    return current.decision === null && allowed ? { ...current, decision } : current;
+  });
+  if (outcome.kind !== "updated")
+    throw new SdkError("invalid", "This approval is no longer waiting.");
+  if (refused)
+    throw new SdkError("denied", "Only the host's owner can allow a tool call.");
+  if (granted === null)
+    throw new SdkError("invalid", "This approval was already answered.");
+  if (decision !== "session")
+    return;
+  await context.api.storage.set(grantKey(granted), true);
+  for (const sibling of openApprovals2(await context.api.session.view())) {
+    if (sibling.part !== context.part.id && sibling.tool === granted)
+      await context.api.session.part(sibling.part).act("once", {});
+  }
+  return;
+}
+var handlers = {
+  once: (_input, context) => decide("once", context),
+  session: (_input, context) => decide("session", context),
+  deny: (_input, context) => decide("deny", context)
+};
+var approval = definePart({
+  ...approval2,
+  onAction: (action, input, context) => handlers[action](input, context)
+});
+async function approveRuntimeCall(call, context) {
+  const { api, signal } = context;
+  const reason = await pendingReason(api, call);
+  if (reason === null)
+    return { kind: "allow" };
+  const part = await api.session.parts.create(approval, {
+    state: { tool: call.name, class: call.class, reason, decision: null },
+    placement: { kind: "modal" }
+  });
+  try {
+    return verdict((await part.answer({ signal }))?.action);
+  } finally {
+    if (signal.aborted)
+      await part.close().catch(() => {
+        return;
+      });
+  }
+}
+var approvals_default = {
+  id: "approvals",
+  contribute: { parts: [approval], settings: [permissions] },
+  approve: approveRuntimeCall,
+  hooks: {
+    before_tool: async (call, context) => {
+      const { api } = context;
+      const definition = api.contribute.tools.list().find((tool) => tool.name === call.name);
+      const reason = await context.memo("reason", () => pendingReason(api, { name: call.name, class: call.class, approval: definition?.approval }));
+      if (reason === null)
+        return { action: "continue" };
+      const part = await api.session.parts.create(approval, {
+        state: { tool: call.name, class: call.class, reason, decision: null },
+        placement: { kind: "modal" }
+      });
+      const outcome = await context.wait({ kind: "part", part: part.id });
+      const answered = verdict(outcome.kind === "part" ? outcome.answer?.action : undefined);
+      return answered.kind === "allow" ? { action: "continue" } : { action: "reject", reason: answered.reason };
+    }
+  }
+};
+export {
+  approval,
+  approvalReason,
+  approvals_default as default,
+  permissions
+};

package/dist/src/approvals/schema.d.ts

@@ -0,0 +1,169 @@
+import type { Infer, PartId, SessionView } from "@nyte-ai/schema";
+declare const policy: import("@nyte-ai/schema").Schema<"ask" | "auto-edit" | "full">;
+/**
+ * When a tool call waits for the user: `ask` before any call that may change
+ * the workspace, `auto-edit` before shell commands, edits outside the
+ * workspace and tools whose effects are unknown, `full` never.
+ */
+export type ApprovalPolicy = Infer<typeof policy>;
+/** The setting that holds the policy; it names the terminal's `/permissions` command. */
+export declare const PERMISSIONS = "permissions";
+/** The policy setting's schema, shared by the plugin and the clients that read it. */
+export declare const approvalPolicy: import("@nyte-ai/schema").Schema<"ask" | "auto-edit" | "full">;
+/** Each policy with the words every client shows for it, in menu order. */
+export declare const APPROVAL_POLICIES: readonly [{
+    readonly value: "ask";
+    readonly label: "Ask first";
+    readonly description: "Asks before every command and file change";
+}, {
+    readonly value: "auto-edit";
+    readonly label: "Auto-edit";
+    readonly description: "Edits workspace files, asks before commands and anything outside";
+}, {
+    readonly value: "full";
+    readonly label: "Full access";
+    readonly description: "Runs every tool without asking";
+}];
+declare const state: import("@nyte-ai/schema").Schema<{
+    class: {
+        kind: "read";
+        path: string;
+    } | {
+        kind: "list";
+        path: string;
+    } | {
+        kind: "edit";
+        path: string;
+    } | {
+        description?: string | undefined;
+        kind: "shell";
+        command: string;
+    } | {
+        kind: "delegate";
+        title: string | null;
+        role: "read" | "task" | "create" | "send" | "await" | "stop";
+        child: import("@nyte-ai/schema").Id<"session"> | null;
+    } | {
+        kind: "custom";
+        label: string;
+    };
+    reason: "edit" | "shell" | "tool" | "outside";
+    tool: string;
+    decision: "session" | "once" | "deny" | null;
+}>;
+/**
+ * One gated tool call: its tool, its class, why it asks (`shell`, `edit` in
+ * the workspace, `outside` the workspace, or another `tool`), and the user's
+ * first decision, null while it waits.
+ */
+export type ApprovalState = Infer<typeof state>;
+/** What the user can answer, as part actions. */
+export type ApprovalDecision = Exclude<ApprovalState["decision"], null>;
+/** The three answers in the order every client offers them, with their shared labels. */
+export declare const APPROVAL_ACTIONS: readonly [{
+    readonly action: "once";
+    readonly label: "Allow once";
+}, {
+    readonly action: "session";
+    readonly label: "Allow for this session";
+}, {
+    readonly action: "deny";
+    readonly label: "Deny";
+}];
+/** The question an approval asks and the command, path or label it is about. */
+export interface ApprovalPrompt {
+    readonly title: string;
+    readonly detail: string;
+}
+/** The words every client shows for an approval. */
+export declare function approvalPrompt(current: Pick<ApprovalState, "tool" | "class" | "reason">): ApprovalPrompt;
+/**
+ * A modal request to run one tool call. Its first answer stands: once,
+ * session (which also allows the tool for the rest of the session), or deny.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const approval: {
+    kind: string;
+    state: import("@nyte-ai/schema").Schema<{
+        class: {
+            kind: "read";
+            path: string;
+        } | {
+            kind: "list";
+            path: string;
+        } | {
+            kind: "edit";
+            path: string;
+        } | {
+            description?: string | undefined;
+            kind: "shell";
+            command: string;
+        } | {
+            kind: "delegate";
+            title: string | null;
+            role: "read" | "task" | "create" | "send" | "await" | "stop";
+            child: import("@nyte-ai/schema").Id<"session"> | null;
+        } | {
+            kind: "custom";
+            label: string;
+        };
+        reason: "edit" | "shell" | "tool" | "outside";
+        tool: string;
+        decision: "session" | "once" | "deny" | null;
+    }>;
+    actions: {
+        once: {
+            input: import("@nyte-ai/schema").Schema<object>;
+        };
+        session: {
+            input: import("@nyte-ai/schema").Schema<object>;
+        };
+        deny: {
+            input: import("@nyte-ai/schema").Schema<object>;
+        };
+    };
+    fallback: (current: {
+        class: {
+            kind: "read";
+            path: string;
+        } | {
+            kind: "list";
+            path: string;
+        } | {
+            kind: "edit";
+            path: string;
+        } | {
+            description?: string | undefined;
+            kind: "shell";
+            command: string;
+        } | {
+            kind: "delegate";
+            title: string | null;
+            role: "read" | "task" | "create" | "send" | "await" | "stop";
+            child: import("@nyte-ai/schema").Id<"session"> | null;
+        } | {
+            kind: "custom";
+            label: string;
+        };
+        reason: "edit" | "shell" | "tool" | "outside";
+        tool: string;
+        decision: "session" | "once" | "deny" | null;
+    }, { id }: {
+        readonly id: PartId;
+    }) => string;
+};
+/** An approval still waiting for the user, with the part its answer goes to. */
+export type OpenApproval = Pick<ApprovalState, "tool" | "class" | "reason"> & {
+    readonly part: PartId;
+};
+/**
+ * Returns the live approvals nobody has answered, oldest first. Parts from a
+ * stopped run and parts with invalid state are left out.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function openApprovals(view: Pick<SessionView, "parts"> | undefined): readonly OpenApproval[];
+export {};