@aparte/plugin-subagents 0.0.0-stage → 1.6.0

package/dist/drawing.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+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;
+    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;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAIH,KAAK,YAAY,EACjB,KAAK,aAAa,EAErB,MAAM,cAAc,CAAC;AAoDtB,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;IA4Bb,4FAA4F;IAC5F,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,OAAO;CASlB"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@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>`).
+ */
+export { setupSubagents } from './setup.js';
+export { subagentOf, subagentStatus } from './status.js';
+export { subagentTranscript } from './transcript.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, } 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;;;;;;;;;;;GAWG;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,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,GAC/B,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+import { A, S, s, a, b, c } from "./setup-CaTzFtu8.js";
+export {
+  A as AparteSubagentView,
+  S as SUBAGENT_SEGMENT_TYPE,
+  s as setupSubagents,
+  a as subagentOf,
+  b as subagentStatus,
+  c 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,16 @@
+/**
+ * `@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 type { AparteSubagentView, SubagentViewSource } from './aparte-subagent-view.js';
+export { SUBAGENT_SEGMENT_TYPE } from './types.js';
+export type { AparteSubagent, AparteSubagentStatus, AparteSubagentSegment, SubagentsOptions, AparteSubagentStartEventDetail, AparteSubagentEndEventDetail, } 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;AAGrD,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,GAC/B,MAAM,YAAY,CAAC"}

package/dist/index.node.js

@@ -0,0 +1,9 @@
+import { S, s, a, b, c } from "./setup-CaTzFtu8.js";
+export {
+  S as SUBAGENT_SEGMENT_TYPE,
+  s as setupSubagents,
+  a as subagentOf,
+  b as subagentStatus,
+  c 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,42 @@
+/**
+ * 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;
+}
+/**
+ * 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;AAuBtB,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;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,CAgdjI"}

package/dist/line.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 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;;;;;;;;;;;;;GAaG;AACH,OAAO,EAMH,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACtB,MAAM,cAAc,CAAC;AAItB,OAAO,KAAK,EAAwC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKzF,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,CAGjF;AA8ED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,gBAAqB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,cAAc,GAAG,SAAS,CAwDjI"}

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"}