@aparte/plugin-subagents 0.0.0-stage → 1.7.0

package/dist/drawing.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How a sub-agent's conversation is drawn: core's own segment renderers, one row per
+ * segment, patched in place.
+ *
+ * Not `<aparte-chat-bubble>`: a bubble is ONE message of a chat, and it draws the chrome of
+ * one — a name and a time over the content, an avatar slot, the app's action bar
+ * (`setBubbleActions` reaches every bubble: Retry and Edit on a sub-agent's text would
+ * dispatch for a message that does not exist), the `‹1/2›` picker, the app's whole frame
+ * (`setBubbleShellRenderer`), `role="article"` named "Message from Assistant", and the
+ * waiting dots. None of it can be switched off without changing core, and hiding it from a
+ * stylesheet would out-specify core's recipes. What a conversation needs from the bubble is
+ * its row loop alone — and that is the renderer contract: `render`, then `setup`; `update`
+ * on a change (following the element when the renderer replaced its own); `relabel` on a
+ * language switch; `cleanup` when the row goes. So this is that loop, and nothing else.
+ *
+ * A row is found by its segment's id and patched when its segment is a new object (a
+ * segment list replaces the object it changes, and only that one), so a token costs the
+ * one row it lands in. A row whose renderer is no longer the one in effect is drawn again —
+ * for a tool call or an activity, the tool or activity renderer too, as the bubble does.
+ */
+import { type AparteConfig, type AparteSegment } from '@aparte/core';
+/** The rows of one conversation, inside `container`. */
+export declare class LaneDrawing {
+    readonly container: HTMLElement;
+    private readonly rows;
+    constructor(container: HTMLElement);
+    /** How many rows are drawn. */
+    get size(): number;
+    /**
+     * Draw `segments`, in order: a new segment gets a row, a changed one is patched, one that
+     * left loses its row. `live`: the sub-agent still works, so what it adds is arriving.
+     */
+    sync(segments: readonly AparteSegment[], config: AparteConfig, live: boolean): void;
+    /** Every row re-reads what it takes from the config (a language switch). */
+    relabel(config: AparteConfig): void;
+    /** Every row goes: each renderer cleans up what it drew. */
+    clear(config: AparteConfig): void;
+    private draw;
+    private patch;
+    /** The row for `id` among the container's own children — never a decoy in a row's prose. */
+    private childOf;
+    /**
+     * The element standing where a row stood (before `next`) when it is no row's: what a
+     * renderer put in place of its own without the id (`outerHTML`, `replaceWith`), stamped so
+     * the loop finds it. A renderer that took its element away left another row there, or
+     * nothing: the row keeps its element, and the loop puts it back.
+     */
+    private inPlaceOf;
+    private release;
+    private cleanup;
+}
+//# sourceMappingURL=drawing.d.ts.map

package/dist/drawing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing.d.ts","sourceRoot":"","sources":["../src/drawing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAKH,KAAK,YAAY,EACjB,KAAK,aAAa,EAGrB,MAAM,cAAc,CAAC;AAiEtB,wDAAwD;AACxD,qBAAa,WAAW;IAGR,QAAQ,CAAC,SAAS,EAAE,WAAW;IAF3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA0B;gBAE1B,SAAS,EAAE,WAAW;IAE3C,+BAA+B;IAC/B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,IAAI,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IA2BnF,4EAA4E;IAC5E,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAQnC,4DAA4D;IAC5D,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAOjC,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,KAAK;IA+Bb,4FAA4F;IAC5F,OAAO,CAAC,OAAO;IAOf;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,OAAO;CASlB"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@aparte/plugin-subagents` — a sub-agent's work, shown as one line.
+ *
+ * Core keeps a sub-agent's events out of the reply (its text is not the reply's, its calls
+ * are not the reply's rows) and lets a plugin observe them. This plugin draws them: the call
+ * that opened a sub-agent becomes its line — name, task, what it is doing now, "3 tools ·
+ * 12 s", and its state — and the sub-agent's conversation is kept on that call, saved with
+ * the conversation and never sent to the model. A sub-agent no call opened gets the same
+ * line, from a segment of the plugin's own. Its conversation can be shown under the line
+ * (`subagentTranscript`, `details: 'transcript'`) or anywhere else
+ * (`<aparte-subagent-view>`), opened from the line's own button with `open: 'event'` and
+ * `connectSubagentView`.
+ */
+export { setupSubagents } from './setup.js';
+export { subagentOf, subagentStatus } from './status.js';
+export { subagentTranscript } from './transcript.js';
+export { connectSubagentView } from './connect.js';
+export type { ConnectSubagentViewOptions, SubagentViewSplit } from './connect.js';
+export { AparteSubagentView } from './aparte-subagent-view.js';
+export type { SubagentViewSource } from './aparte-subagent-view.js';
+export { SUBAGENT_SEGMENT_TYPE } from './types.js';
+export type { AparteSubagent, AparteSubagentStatus, AparteSubagentSegment, SubagentsOptions, AparteSubagentStartEventDetail, AparteSubagentEndEventDetail, AparteSubagentOpenEventDetail, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,YAAY,EACR,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,8BAA8B,EAC9B,4BAA4B,EAC5B,6BAA6B,GAChC,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+import { A, S, c, s, a, b, d } from "./connect-65jiVmf_.js";
+export {
+  A as AparteSubagentView,
+  S as SUBAGENT_SEGMENT_TYPE,
+  c as connectSubagentView,
+  s as setupSubagents,
+  a as subagentOf,
+  b as subagentStatus,
+  d as subagentTranscript
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/index.node.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@aparte/plugin-subagents` — the DOM-free entry, for Node and SSR.
+ *
+ * Everything the browser entry exports but the element is DOM-free at import: the observer
+ * and the line are plain functions, the `subagent` segment's renderer only builds DOM when a
+ * chat draws it — in a browser — and `subagentTranscript` returns `''` without a document. So `setupSubagents()` here installs the same three pieces, and a
+ * conversation rendered on a server reads its sub-agents' state through `subagentOf` and
+ * `subagentStatus`. `scripts/check-node-import.mjs` asserts this entry imports without a DOM.
+ */
+export { setupSubagents } from './setup.js';
+export { subagentOf, subagentStatus } from './status.js';
+export { subagentTranscript } from './transcript.js';
+export { connectSubagentView } from './connect.js';
+export type { ConnectSubagentViewOptions, SubagentViewSplit } from './connect.js';
+export type { AparteSubagentView, SubagentViewSource } from './aparte-subagent-view.js';
+export { SUBAGENT_SEGMENT_TYPE } from './types.js';
+export type { AparteSubagent, AparteSubagentStatus, AparteSubagentSegment, SubagentsOptions, AparteSubagentStartEventDetail, AparteSubagentEndEventDetail, AparteSubagentOpenEventDetail, } from './types.js';
+//# sourceMappingURL=index.node.d.ts.map

package/dist/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../src/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGlF,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,YAAY,EACR,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,8BAA8B,EAC9B,4BAA4B,EAC5B,6BAA6B,GAChC,MAAM,YAAY,CAAC"}

package/dist/index.node.js

@@ -0,0 +1,10 @@
+import { S, c, s, a, b, d } from "./connect-65jiVmf_.js";
+export {
+  S as SUBAGENT_SEGMENT_TYPE,
+  c as connectSubagentView,
+  s as setupSubagents,
+  a as subagentOf,
+  b as subagentStatus,
+  d as subagentTranscript
+};
+//# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/lanes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The lanes: each sub-agent's conversation, kept apart from the reply and saved on the
+ * segment that stands for it.
+ *
+ * Core keeps a sub-agent's events out of the reply and hands every event of the run to the
+ * observers of `observeRunEvents`. This observer gives each sub-agent a lane: a segment list
+ * (`createSegmentList`) written by a stream adapter of core's own (`createStreamAdapter`), fed
+ * the sub-agent's events with their `agentId` taken off, so the lane holds exactly what a
+ * reply would — text, reasoning, its tool calls, stamped the same way.
+ *
+ * A lane lives on its ANCHOR, the segment that stands for the sub-agent: the call that opened
+ * it (`tool-<toolCallId>`, in a field `subagent`), or — with no call, or for the second
+ * sub-agent of one call — a `subagent` segment of the plugin's own, added to the reply. A
+ * sub-agent of a sub-agent follows the same two rules inside its parent's lane. The anchor is
+ * written once per animation frame while text streams, and at once for everything a person
+ * must see or the conversation must keep: a new segment, a tool's state, the sub-agent's end,
+ * the run's end or pause — the conversation is saved on those, so the lane is on the segment
+ * before anyone saves it.
+ *
+ * Memory is per reply, emptied when its run ends (done, stopped, failed), kept across a pause
+ * (the run resumes into the same reply), and capped.
+ */
+import { type AparteRunEventContext, type AparteSegment, type AparteStreamRunEvent } from '@aparte/core';
+/** A sub-agent's anchor, just written: which chat, which reply, which agent, and the segment as it is now. */
+export interface LaneWrite {
+    readonly target: object;
+    readonly targetId?: string;
+    readonly messageId: string;
+    readonly agentId: string;
+    readonly anchor: AparteSegment;
+}
+/** The last anchor written for this sub-agent while its run goes on, if any. */
+export declare function lastLaneWrite(messageId: string, agentId: string): LaneWrite | undefined;
+/**
+ * Hear every sub-agent's anchor as it is written — once a frame while it streams, at once
+ * for everything else. What `<aparte-subagent-view>` follows a live sub-agent with.
+ */
+export declare function watchLaneWrites(fn: (write: LaneWrite) => void): () => void;
+/** The observer of one setup, and what forgets everything it follows. */
+export declare function createLanes(): {
+    observe: (event: AparteStreamRunEvent, ctx: AparteRunEventContext) => void;
+    dispose: () => void;
+};
+//# sourceMappingURL=lanes.d.ts.map

package/dist/lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.d.ts","sourceRoot":"","sources":["../src/lanes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAIH,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAGlB,KAAK,oBAAoB,EAG5B,MAAM,cAAc,CAAC;AAwBtB,8GAA8G;AAC9G,MAAM,WAAW,SAAS;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAClC;AAWD,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAEvF;AAKD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAG1E;AAqGD,yEAAyE;AACzE,wBAAgB,WAAW,IAAI;IAAE,OAAO,EAAE,CAAC,KAAK,EAAE,oBAAoB,EAAE,GAAG,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA4djI"}

package/dist/line.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A sub-agent's line: core's tool row, named by what ran it.
+ *
+ * The plugin gives core a tool-line provider (`setToolLineProvider`): for a call that carries
+ * a sub-agent — the call that opened it, or the call the plugin's own segment stands in for —
+ * it says the sub-agent's name and its task, and on a second line, from the sub-agent's start to
+ * its end, what it is on ("Starting…", then its running call, else the step it announced, else
+ * its latest call) and once it is over what it did
+ * ("3 tools · 12s"). The second line is there the whole time, so the row keeps its height: one
+ * that grew a line when the sub-agent began acting and lost it at its end moved every row under
+ * it twice, and a count that grew beside the task moved the task. Core reads it AFTER the app's
+ * `registerToolDisplay`, field by field, so the app's label, summary and details always win. It
+ * is asked at every draw, update and relabel and stores nothing: the counts and the words follow
+ * the reader's language.
+ */
+import { type AparteToolCallSegment, type AparteToolLine } from '@aparte/core';
+import type { SubagentsOptions } from './types.js';
+/** Mark a call built to draw a `subagent` segment with core's row. */
+export declare function markStandIn(segment: AparteToolCallSegment): AparteToolCallSegment;
+/**
+ * The provider: the line of every call that carries a sub-agent, `undefined` for any other
+ * call (core's own line then).
+ */
+export declare function createLineProvider(options?: SubagentsOptions): (segment: AparteToolCallSegment) => AparteToolLine | undefined;
+//# sourceMappingURL=line.d.ts.map

package/dist/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../src/line.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAMH,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACtB,MAAM,cAAc,CAAC;AAMtB,OAAO,KAAK,EAAwC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKzF,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,CAGjF;AAgFD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,gBAAqB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,cAAc,GAAG,SAAS,CAkEjI"}

package/dist/open.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A sub-agent's line opens its conversation elsewhere: what the line says (the Open button,
+ * which one is shown now) and what pressing it dispatches.
+ *
+ * The line provider gives core an `open` for every sub-agent's line when the setup asks for
+ * it; core draws the button and calls back with the row. The plugin then dispatches
+ * `aparte-subagent-open` from the row, and the app (or `connectSubagentView`) decides where the
+ * conversation goes. Which sub-agent is shown is kept here, by whoever shows it, so a line
+ * drawn again — a reload, a row rebuilt — still says it is the one open.
+ */
+import type { AparteToolCallSegment } from '@aparte/core';
+import type { AparteSubagent } from './types.js';
+/** Whether some view shows this sub-agent now. */
+export declare function isShown(messageId: string | undefined, agentId: string): boolean;
+/** `owner` shows this sub-agent now, or nothing (`null`). */
+export declare function setShown(owner: object, at: {
+    messageId: string;
+    agentId: string;
+} | null): void;
+/**
+ * The row's Open button: core's, in its own line, or — a row with a detail — in the slot
+ * beside its disclosure (never in a summary, never a nested row's).
+ */
+export declare const openButtonOf: (row: Element) => HTMLElement | null;
+/**
+ * Mark a row as the one shown, or not: the two marks core writes from `open.current` when it
+ * draws the row, written here on a row already drawn so it does not wait for its next draw.
+ */
+export declare function markRow(row: Element, on: boolean): void;
+/** Every row marked as shown under `root`, unmarked. */
+export declare function unmarkAll(root: ParentNode): void;
+/** Dispatch `aparte-subagent-open` from the row of `sub`, drawn for `segment`. */
+export declare function dispatchOpen(row: HTMLElement, segment: AparteToolCallSegment, sub: AparteSubagent, standIn: boolean): void;
+//# sourceMappingURL=open.d.ts.map

package/dist/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../src/open.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAiC,MAAM,YAAY,CAAC;AAOhF,kDAAkD;AAClD,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAK/E;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,IAAI,CAG/F;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAS,OAAO,KAAG,WAAW,GAAG,IACuD,CAAC;AAElH;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAMvD;AAED,wDAAwD;AACxD,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAEhD;AAeD,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAc1H"}

package/dist/segment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The line of a sub-agent no call opened: core's own tool row, drawn for a stand-in call.
+ *
+ * A sub-agent announced without a call (an AG-UI `SUBAGENT_STARTED` with no parent call), or
+ * the second one a call opens, has no row of its own in the reply, so the plugin adds a
+ * `subagent` segment for it. That segment is drawn by core's `tool_call` renderer, handed a
+ * call that stands for the agent: its name is the agent's (so `registerToolDisplay('<agent
+ * name>', …)` reaches it — label, icon, `quiet`, `hidden`, `details`), its status says the
+ * agent's. The renderer returns the row's own root — no wrapper — and forwards `setup`,
+ * `update`, `relabel` and `cleanup` to core's, so the line reads and behaves exactly like a
+ * call's sub-agent line.
+ */
+import { type AparteSegmentRenderer, type AparteToolCallSegment } from '@aparte/core';
+import { type AparteSubagentSegment } from './types.js';
+/** The tool name a sub-agent with no name stands in under. */
+export declare const UNNAMED_AGENT = "subagent";
+/** The call that stands for a `subagent` segment on core's row: same id, the agent's name, its status. */
+export declare function standInCall(segment: AparteSubagentSegment): AparteToolCallSegment;
+export declare const subagentRenderer: AparteSegmentRenderer<AparteSubagentSegment>;
+//# sourceMappingURL=segment.d.ts.map

package/dist/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../src/segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAGH,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC7B,MAAM,cAAc,CAAC;AAItB,OAAO,EAAyB,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE/E,8DAA8D;AAC9D,eAAO,MAAM,aAAa,aAAa,CAAC;AAExC,0GAA0G;AAC1G,wBAAgB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,CAkBjF;AAgBD,eAAO,MAAM,gBAAgB,EAAE,qBAAqB,CAAC,qBAAqB,CAsBzE,CAAC"}

package/dist/setup.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `setupSubagents()`: one line per sub-agent, on the config last, like every setup.
+ */
+import { type AparteConfig } from '@aparte/core';
+import { type SubagentsOptions } from './types.js';
+/**
+ * Show each sub-agent of a reply as one line: the line of the call that opened it — its
+ * name, its task, what it is doing now, "3 tools · 12 s" — and its conversation kept on that
+ * call, out of the reply and out of what the model reads. A sub-agent no call opened gets the
+ * same line, from a segment of the plugin's own.
+ *
+ * Installs one run-event observer, one tool-line provider and the `subagent` segment's
+ * renderer on `config` (the global config by default). Returns the function that takes them
+ * off; calling it again on the same config replaces the first setup.
+ *
+ * @example
+ * import { setupSubagents } from '@aparte/plugin-subagents';
+ * setupSubagents();                          // the line alone
+ * setupSubagents({ counts: false });         // without "3 tools · 12 s"
+ * setupSubagents({ details: 'transcript' }); // its conversation under the line, closed
+ */
+export declare function setupSubagents(options?: SubagentsOptions, config?: AparteConfig): () => void;
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAKH,KAAK,YAAY,EACpB,MAAM,cAAc,CAAC;AAItB,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAK1E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,gBAAqB,EAAE,MAAM,GAAE,YAAiC,GAAG,MAAM,IAAI,CAoBpH"}

package/dist/status.d.ts

@@ -0,0 +1,24 @@
+/**
+ * What a sub-agent's line says it is doing, read off the segment alone — so a reload and a
+ * Stop read right with no bookkeeping of their own.
+ */
+import type { AparteSegment, AparteToolCallSegment } from '@aparte/core';
+import { type AparteSubagent, type AparteSubagentStatus } from './types.js';
+/**
+ * The sub-agent a segment stands for: the one kept on a `tool_call` segment (the call that
+ * opened it) or on a `subagent` segment. `undefined` for any other segment.
+ */
+export declare function subagentOf(segment: AparteSegment): AparteSubagent | undefined;
+/**
+ * Where the sub-agent a segment stands for is: its stored status, except that one stored as
+ * working (`running`, `waiting`) reads `stopped` once its segment has settled without it — the
+ * call that opened it is over, or its own segment streams no more. That is what a reloaded
+ * conversation and a Stop look like: nothing will ever end it. A segment that stands for no
+ * sub-agent reads `stopped`.
+ */
+export declare function subagentStatus(segment: AparteSegment): AparteSubagentStatus;
+/** What a call's own status says of a sub-agent, as its row shows it. */
+export declare function statusOfCall(status: AparteToolCallSegment['status'] | undefined): AparteSubagentStatus;
+/** The call status that says a sub-agent's status on a row — the reverse of {@link statusOfCall}. */
+export declare function callStatusOf(status: AparteSubagentStatus): AparteToolCallSegment['status'];
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAInG;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,CAY7E;AAWD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB,CAK3E;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,MAAM,EAAE,qBAAqB,CAAC,QAAQ,CAAC,GAAG,SAAS,GAAG,oBAAoB,CAQtG;AAED,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,MAAM,EAAE,oBAAoB,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAQ1F"}

package/dist/steps.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The steps a sub-agent has open ("Reading the parser"), live: what its line says while none
+ * of its calls runs.
+ *
+ * Kept here, by reply and by agent, and never on a segment: a step lasts only as long as it is
+ * open, and the conversation a page saves must not keep one. The lanes write it as the
+ * sub-agent's `step-start` / `step-end` arrive and forget it with the sub-agent's end; the line
+ * reads it at each draw. Steps nest and overlap: the latest one open is the one said, and when
+ * it ends the one before it is said again.
+ */
+/** A step of the sub-agent `agentId` of the reply `messageId` begins. */
+export declare function stepStarted(messageId: string, agentId: string, name: string): void;
+/** The latest open step of that name ends. */
+export declare function stepEnded(messageId: string, agentId: string, name: string): void;
+/** Every step of the sub-agent ends: it ended, or its reply did. */
+export declare function stepsEnded(messageId: string, agentId: string): void;
+/**
+ * The step the sub-agent is on, if any. Without the reply's id (a segment that does not carry
+ * one), the first sub-agent of that id with a step open.
+ */
+export declare function currentStep(messageId: string | undefined, agentId: string): string | undefined;
+//# sourceMappingURL=steps.d.ts.map

package/dist/steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../src/steps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAGlF;AAED,8CAA8C;AAC9C,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAShF;AAED,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAEnE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK9F"}

package/dist/styles.d.ts

@@ -0,0 +1,5 @@
+/** What the segment renderer hands core: the sheet, unless the element already put it on the page. */
+export declare function rendererStyles(): string;
+/** Put the sheet on the page, unless it is there already. */
+export declare function ensureStyles(): void;
+//# sourceMappingURL=styles.d.ts.map

package/dist/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../src/styles.ts"],"names":[],"mappings":"AAsBA,sGAAsG;AACtG,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,6DAA6D;AAC7D,wBAAgB,YAAY,IAAI,IAAI,CAOnC"}

package/dist/transcript.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `subagentTranscript` — a sub-agent's conversation under its line.
+ *
+ * A tool display's `details`: core calls it when the row is drawn and on every update of the
+ * call, and leaves in place an element it already holds (so the conversation is never
+ * serialised or rewritten per token). It returns the SAME `<aparte-subagent-view>` for one
+ * sub-agent of one reply on every call, and hands it the call as it is now: the view patches
+ * the rows that changed and nothing else.
+ */
+import { type AparteToolDetails } from '@aparte/core';
+/**
+ * A sub-agent's conversation, for a tool display's `details`: its task, then its text, its
+ * reasoning and its own tool rows, drawn by the same renderers as the reply, kept up to date
+ * while it works. `''` for a call that opened no sub-agent, and for one that has nothing to
+ * show yet — no disclosure until there is.
+ *
+ * `setupSubagents({ details: 'transcript' })` puts it under every sub-agent's line; register
+ * it yourself to put it under one tool's only.
+ *
+ * @example
+ * import { aparteGlobalConfig } from '@aparte/core';
+ * import { setupSubagents, subagentTranscript } from '@aparte/plugin-subagents';
+ *
+ * setupSubagents();
+ * aparteGlobalConfig.registerToolDisplay('task', { details: subagentTranscript, open: true });
+ */
+export declare const subagentTranscript: AparteToolDetails;
+//# sourceMappingURL=transcript.d.ts.map

package/dist/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../src/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAoC,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AASxF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBA0BhC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * The shapes the plugin writes and reads: a sub-agent, as it is kept on the segment that
+ * stands for it, the plugin's own segment for a sub-agent no call opened, the options, and
+ * the two events an app hears.
+ */
+import type { AparteSegment, AparteSegmentBase, AparteToolDetails } from '@aparte/core';
+/** Where a sub-agent is: working, waiting for a person, or over — and how. */
+export type AparteSubagentStatus = 'running' | 'waiting' | 'done' | 'failed' | 'stopped';
+/**
+ * A sub-agent, as it is saved with the conversation: on the call that opened it (the
+ * `subagent` field of that `tool_call` segment), or on a `subagent` segment of its own.
+ *
+ * `segments` is its conversation — its text, its reasoning, its own tool calls — stamped
+ * like a message's, and never part of the reply: the model never reads it back.
+ */
+export interface AparteSubagent {
+    /** The sub-agent's id in the run (`agent-start`'s `agentId`). */
+    id: string;
+    /** Its name, what the line shows. */
+    name?: string;
+    /** What it was asked to do, shown after the name. */
+    description?: string;
+    /** As stored. Read it through `subagentStatus`, which knows a saved run is over. */
+    status: AparteSubagentStatus;
+    /** What it answered, when it is done. */
+    result?: string;
+    /** Why it failed, when it failed. */
+    error?: string;
+    /** The sub-agent that opened this one, when one did. */
+    parentId?: string;
+    /** Its conversation. */
+    segments: AparteSegment[];
+}
+/** The segment type of a sub-agent that no call opened. */
+export declare const SUBAGENT_SEGMENT_TYPE = "subagent";
+/**
+ * A sub-agent no call opened (or a second one opened by the same call): a segment of the
+ * plugin's own, drawn as the same line a call's sub-agent gets. `isStreaming` is true while
+ * it works.
+ */
+export interface AparteSubagentSegment extends AparteSegmentBase {
+    type: typeof SUBAGENT_SEGMENT_TYPE;
+    subagent: AparteSubagent;
+}
+declare module '@aparte/core' {
+    interface AparteSegmentTypes {
+        subagent: AparteSubagentSegment;
+    }
+}
+/** What `setupSubagents` shows on a sub-agent's line. */
+export interface SubagentsOptions {
+    /** What it is doing now — its latest running tool call — while it works. Default `true`. */
+    activity?: boolean;
+    /** "3 tools · 12 s" after the line: its tool calls and how long it worked. Default `true`. */
+    counts?: boolean;
+    /**
+     * What is behind the line. `false` (the default): the line alone, with no disclosure.
+     * A function: what it returns is shown under the line, as a tool display's `details`.
+     * `'transcript'`: the sub-agent's conversation under the line (`subagentTranscript`),
+     * closed until the reader opens it — or open, with the tool display's `open: true`.
+     */
+    details?: false | 'transcript' | AparteToolDetails;
+    /**
+     * What the line can open elsewhere. `'event'`: an Open button at the end of the line
+     * dispatches `aparte-subagent-open`, for the app to show the sub-agent's conversation
+     * somewhere else (`connectSubagentView` shows it in an `<aparte-subagent-view>` beside the
+     * chat). A line with nothing behind it opens on a click anywhere on it too; with `details`,
+     * the line keeps opening its detail and only the button opens elsewhere. Left out (the
+     * default), the line opens nothing: no button, no pointer.
+     */
+    open?: false | 'event';
+}
+/**
+ * A sub-agent started working for a reply, or started again after a pause. Bubbles out of
+ * the chat, so an app can list a reply's sub-agents wherever it likes; the detail says which
+ * call or which sub-agent opened it, when one did.
+ *
+ * @event aparte-subagent-start
+ */
+export interface AparteSubagentStartEventDetail {
+    /** The chat the reply is in. */
+    targetId?: string;
+    /** The reply the sub-agent works for. */
+    messageId: string;
+    agentId: string;
+    name?: string;
+    description?: string;
+    /** The call that opened it, when one did. */
+    toolCallId?: string;
+    /** The sub-agent that opened it, when one did. */
+    parentId?: string;
+}
+/**
+ * A sub-agent ended, or the run ended without it: `status` says how (`done`, `failed`,
+ * `waiting` for a person, `stopped`). Bubbles out of the chat.
+ *
+ * @event aparte-subagent-end
+ */
+export interface AparteSubagentEndEventDetail {
+    /** The chat the reply is in. */
+    targetId?: string;
+    messageId: string;
+    agentId: string;
+    status: AparteSubagentStatus;
+}
+/**
+ * A reader pressed a sub-agent's Open button (`setupSubagents({ open: 'event' })`): show its
+ * conversation elsewhere — an `<aparte-subagent-view>` with this `messageId` and `agentId`.
+ * Dispatched from the line, bubbles and is composed.
+ *
+ * @event aparte-subagent-open
+ */
+export interface AparteSubagentOpenEventDetail {
+    /** The chat the reply is in, when the line knows it. */
+    targetId?: string;
+    /** The reply the sub-agent works for: a view's `message-id`. */
+    messageId: string;
+    /** Which sub-agent: a view's `agent-id`. */
+    agentId: string;
+    name?: string;
+    /** The call that opened it, when its line is that call's row. */
+    toolCallId?: string;
+}
+declare global {
+    interface HTMLElementEventMap {
+        'aparte-subagent-start': CustomEvent<AparteSubagentStartEventDetail>;
+        'aparte-subagent-end': CustomEvent<AparteSubagentEndEventDetail>;
+        'aparte-subagent-open': CustomEvent<AparteSubagentOpenEventDetail>;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAExF,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzF;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC3B,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,qCAAqC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,MAAM,EAAE,oBAAoB,CAAC;IAC7B,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,iBAAiB;IAC5D,IAAI,EAAE,OAAO,qBAAqB,CAAC;IACnC,QAAQ,EAAE,cAAc,CAAC;CAC5B;AAED,OAAO,QAAQ,cAAc,CAAC;IAC1B,UAAU,kBAAkB;QACxB,QAAQ,EAAE,qBAAqB,CAAC;KACnC;CACJ;AAED,yDAAyD;AACzD,MAAM,WAAW,gBAAgB;IAC7B,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8FAA8F;IAC9F,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,YAAY,GAAG,iBAAiB,CAAC;IACnD;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,8BAA8B;IAC3C,gCAAgC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IACzC,gCAAgC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,oBAAoB,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,6BAA6B;IAC1C,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,mBAAmB;QACzB,uBAAuB,EAAE,WAAW,CAAC,8BAA8B,CAAC,CAAC;QACrE,qBAAqB,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;QACjE,sBAAsB,EAAE,WAAW,CAAC,6BAA6B,CAAC,CAAC;KACtE;CACJ"}