@deepseek-harness-tui/dsh-tui 0.14.1 → 0.16.0

package/lib/types/dsh-adapter/team-mode.js

@@ -0,0 +1,188 @@
+import { t } from '../i18n.js';
+import { resolveDshProfileName } from '../update.js';
+import { installedKernelVersion, UPSTREAM_VALIDATED_VERSION } from './contract.js';
+import { createPluginManageFlow } from './plugin-manage.js';
+import { pluginManagerOf } from './plugin-manager.js';
+import { cell } from './plugins-info.js';
+import { TEAM_BUNDLE } from './team-roster.js';
+import { TEAM_SPAWN_TOOL } from './team-tools.js';
+/**
+ * The DSH lines whose team bundle this adapter reads: the validated line,
+ * 0.2.1-alpha.5 (its team packages differ from rc.2 only in version) and the
+ * 0.2.0 compat line (compat/agent-team-0.2.0.ts; rc.1 ships the same team
+ * code as rc.2). Other lines' team projection may lack the `wire` view
+ * `channel.team` needs.
+ */
+const TEAM_LINES = new Set([UPSTREAM_VALIDATED_VERSION, '0.2.1-alpha.5', '0.2.0-rc.1', '0.2.0-rc.2']);
+/**
+ * The install spec the hints name. The team packages ship in lockstep with
+ * DSH and pin their DSH peers exactly, so only the bundle of the running
+ * kernel's own version installs into this host (npm `latest` and `next`
+ * both name other lines).
+ * @param kernel - The running DSH version; unknown falls back to the validated line.
+ * @returns `<bundle>@<version>`, or undefined on a known kernel that is not a
+ *   team line: no bundle installs there, DSH has to move to a team line first.
+ */
+export function teamBundleSpec(kernel) {
+    if (kernel === undefined)
+        return `${TEAM_BUNDLE}@${UPSTREAM_VALIDATED_VERSION}`;
+    return TEAM_LINES.has(kernel) ? `${TEAM_BUNDLE}@${kernel}` : undefined;
+}
+/**
+ * Legacy delegation tools that `spawn_teammate` replaces. The four control
+ * tools the team shares names with (`send_message`, `list_agents`,
+ * `interrupt_agent`, `wait_agent`) need no entry: the team copies live in the
+ * Agent's own scope and shadow the preset's, in the assembly and at execution.
+ */
+const TEAM_REPLACED_TOOLS = new Set(['subagent', 'subagent_fork']);
+/**
+ * Keep one delegation tool set per request. Presets keep their legacy rows,
+ * so whether the team replaces them is decided where the tools are known: an
+ * assembly carrying `spawn_teammate` drops `subagent` / `subagent_fork`. This
+ * follows a bundle toggled at run time into the sessions already joined (a
+ * preset revision cannot), and a team service that never activated leaves the
+ * legacy tools in place. The agent loop diffs these final tools against the
+ * logged request header, so the model is told about each swap.
+ * @param assembly - Fully assembled prompt inputs for one model request.
+ * @returns The original assembly, or a copy without the replaced tools.
+ */
+export function filterTeamReplacedTools(assembly) {
+    if (!assembly.tools.some(tool => tool.name === TEAM_SPAWN_TOOL))
+        return assembly;
+    if (!assembly.tools.some(tool => TEAM_REPLACED_TOOLS.has(tool.name)))
+        return assembly;
+    return { ...assembly, tools: assembly.tools.filter(tool => !TEAM_REPLACED_TOOLS.has(tool.name)) };
+}
+export function parseTeamArgs(args) {
+    const sub = args.trim().split(/\s+/)[0] ?? '';
+    if (sub === '' || sub === 'status')
+        return { kind: 'status' };
+    if (sub === 'on' || sub === 'off')
+        return { kind: sub };
+    return { kind: 'unknown', sub };
+}
+/**
+ * Wire `/team` to the running composition.
+ * @param ctx - Host context of the composition root.
+ * @param options - The profile a manual route names, and the running host's
+ *   DSH version (this package's entry; otherwise the installed one is read).
+ * @returns the command entry the screen calls.
+ */
+export function createTeamCommandEntry(ctx, options = {}) {
+    const profile = () => options.profileName ?? resolveDshProfileName() ?? 'dsh-tui';
+    // The version does not change in a process: read it once, on the first hint.
+    let kernel;
+    const hint = (key) => {
+        kernel ??= { version: options.kernelVersion ?? installedKernelVersion() };
+        const spec = teamBundleSpec(kernel.version);
+        return spec === undefined
+            ? t('team-cmd-kernel-unsupported', { version: cell(kernel.version ?? ''), lines: [...TEAM_LINES].join(' / ') })
+            : t(key, { profile: cell(profile()), bundle: spec });
+    };
+    return (args, sink) => {
+        const parsed = parseTeamArgs(args);
+        if (parsed.kind === 'unknown') {
+            return { kind: 'lines', lines: Promise.resolve([t('team-cmd-usage', { sub: cell(parsed.sub) })]) };
+        }
+        const manager = pluginManagerOf(ctx);
+        if (parsed.kind === 'status')
+            return { kind: 'lines', lines: teamStatusLines(ctx, sink, hint) };
+        if (manager === undefined) {
+            return { kind: 'lines', lines: Promise.resolve([hint('team-cmd-no-manager')]) };
+        }
+        const flow = createPluginManageFlow({
+            manager,
+            action: parsed.kind === 'on' ? 'enable' : 'disable',
+            target: TEAM_BUNDLE,
+            binding: sink.binding,
+            busy: sink.busy,
+            onLines: sink.onLines,
+            profileName: profile(),
+            teamActiveMembers: sink.members,
+        });
+        // Without the package the lifecycle flow would answer with its generic
+        // "no such target" and every addressable name. Say what is missing
+        // instead: `on` with how to install it (installing stays an explicit
+        // `/plugin install`, it runs third-party code behind its own trust step),
+        // `off` that there is nothing to switch off.
+        const bindingAtStart = sink.binding();
+        return {
+            kind: 'flow',
+            flow: {
+                ...flow,
+                async begin() {
+                    let installed = true;
+                    let enabled = false;
+                    try {
+                        const entry = (await manager.listBundles()).find(candidate => candidate.name === TEAM_BUNDLE);
+                        installed = entry !== undefined;
+                        enabled = entry?.enabled === true;
+                    }
+                    catch {
+                        // A failing read is the flow's to report: it reads the same list.
+                    }
+                    if (parsed.kind === 'off') {
+                        if (installed)
+                            return flow.begin();
+                        if (sink.binding() === bindingAtStart)
+                            sink.onLines([t('team-cmd-off-not-installed')]);
+                        return { kind: 'done' };
+                    }
+                    // Already selected: no trust question about code already running,
+                    // no no-op write. Say whether it is actually running.
+                    if (installed && !enabled)
+                        return flow.begin();
+                    if (sink.binding() === bindingAtStart) {
+                        sink.onLines(!installed
+                            ? [hint('team-cmd-not-installed')]
+                            : [t('team-cmd-already-on'), ...ctx.get('agentTeams', false) === undefined ? [t('team-cmd-pending-on')] : []]);
+                    }
+                    return { kind: 'done' };
+                },
+            },
+        };
+    };
+}
+/**
+ * `/team` and `/team status`: whether the profile selects the bundle, whether
+ * the team service is running in this process, and the bound session's team.
+ */
+async function teamStatusLines(ctx, sink, hint) {
+    const manager = pluginManagerOf(ctx);
+    const service = ctx.get('agentTeams', false) !== undefined;
+    const lines = [];
+    if (manager === undefined) {
+        lines.push(t('team-cmd-service', { state: t(service ? 'team-cmd-running' : 'team-cmd-stopped') }));
+        lines.push(hint('team-cmd-no-manager'));
+    }
+    else {
+        let selected;
+        let installed = false;
+        try {
+            const bundle = (await manager.listBundles()).find(candidate => candidate.name === TEAM_BUNDLE);
+            installed = bundle !== undefined;
+            selected = bundle?.enabled;
+        }
+        catch (error) {
+            lines.push(t('plugins-service-error', { err: cell(error instanceof Error ? error.message : String(error)) }));
+        }
+        if (selected !== undefined || installed) {
+            lines.push(t('team-cmd-bundle', { state: t(selected === true ? 'team-cmd-on' : 'team-cmd-off') }));
+        }
+        else if (lines.length === 0) {
+            lines.push(hint('team-cmd-not-installed'));
+        }
+        lines.push(t('team-cmd-service', { state: t(service ? 'team-cmd-running' : 'team-cmd-stopped') }));
+        // The profile says on but nothing runs (a startup-only profile, or the
+        // service failed to activate), or the reverse: say which one wins now.
+        if (selected === true && !service)
+            lines.push(t('team-cmd-pending-on'));
+        if (selected === false && service)
+            lines.push(t('team-cmd-pending-off'));
+    }
+    const { total, active, unseen } = sink.members();
+    lines.push(total === 0
+        ? t('team-cmd-no-members')
+        : t(unseen === 0 ? 'team-cmd-members' : 'team-cmd-members-unseen', { total: String(total), active: String(active), unseen: String(unseen) }));
+    return lines;
+}

package/lib/types/dsh-adapter/team-roster.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Read side of DSH's experimental Agent Teams: the Lead session's `agentTeam`
+ * projection (roster + non-deleted task board), folded for the session on
+ * screen. Inside a teammate it reads the Lead's value, found through the
+ * teammate header's `parentSession` (another child of the Lead reads none).
+ *
+ * The wire value is narrowed locally (`@deepseek-ai/dsh-experimental-agent-team`
+ * is never imported); a composition without the team service never publishes
+ * the key and the store stays empty.
+ *
+ * @module
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { TeamView } from '../adapter/ports/channel-view.js';
+import { type SessionProjectionStore, type WatchedSession } from './session-projection-store.js';
+export declare const TEAM_PROJECTION_KEY = "agentTeam";
+/** The upstream bundle that mounts the team service and tools: the team-mode switch. */
+export declare const TEAM_BUNDLE = "@deepseek-ai/dsh-experimental-agent-team-profile";
+/** What the channel reads: the team of one session, if any. */
+export interface TeamSource {
+    /** The team of `sessionId` — `undefined` unless it is the session last
+     *  seeded (a non-DSH session never seeds, so it never reads a stale team). */
+    teamOf(sessionId: string): TeamView | undefined;
+    subscribe(listener: () => void): () => void;
+}
+export type TeamRosterStore = SessionProjectionStore<TeamView> & TeamSource;
+/**
+ * Narrow one `agentTeam` value into the view the UI renders. A session's
+ * implicit team (the Lead alone, no task, no failure) is no team: every root
+ * session publishes that baseline once the service is mounted.
+ * @param value - Raw projection value.
+ * @param leadSessionId - The session the value was published for.
+ * @returns the team view, or `undefined` when there is nothing to show.
+ */
+export declare function asTeamView(value: unknown, leadSessionId: string): TeamView | undefined;
+interface AgentsLike {
+    list(): Iterable<{
+        readonly session: {
+            readonly id: unknown;
+        };
+    }>;
+}
+/**
+ * The team a bound session belongs to is rooted at itself, or — for a
+ * delegated child — at its parent: teammates are direct children of the Lead.
+ * @param session - The bound session.
+ * @param agents - Live agents, to find the Lead's session object for a baseline.
+ * @returns the session whose `agentTeam` value to read.
+ */
+export declare function teamRootOf(session: unknown, agents: AgentsLike | undefined): WatchedSession;
+/**
+ * The watched team as seen from `sessionId`: the Lead's own, or a listed
+ * teammate's. Any other child of the Lead (a plain subagent, a workflow
+ * spawn) is watched at the same parent but belongs to no team.
+ * @param team - The watched session's team.
+ * @param sessionId - The bound session.
+ * @returns the team, or `undefined` when the session is not on it.
+ */
+export declare function teamFor(team: TeamView | undefined, sessionId: string): TeamView | undefined;
+/**
+ * Create the composition root's team store and wire it to the host.
+ * @param ctx - Host context of the composition root.
+ * @returns the store the channel reads from.
+ */
+export declare function createTeamRosterStore(ctx: Context): TeamRosterStore;
+export {};
+//# sourceMappingURL=team-roster.d.ts.map

package/lib/types/dsh-adapter/team-roster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-roster.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/team-roster.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAwB,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AACtF,OAAO,EAAyD,KAAK,sBAAsB,EAAE,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEvJ,eAAO,MAAM,mBAAmB,cAAc,CAAA;AAE9C,wFAAwF;AACxF,eAAO,MAAM,WAAW,qDAAqD,CAAA;AAE7E,+DAA+D;AAC/D,MAAM,WAAW,UAAU;IACzB;kFAC8E;IAC9E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC/C,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;CAC5C;AAED,MAAM,MAAM,eAAe,GAAG,sBAAsB,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAA;AAkC3E;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAUtF;AAOD,UAAU,UAAU;IAClB,IAAI,IAAI,QAAQ,CAAC;QAAE,QAAQ,CAAC,OAAO,EAAE;YAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAC,CAAA;CACjE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,CAQ3F;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAG3F;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,CAyBnE"}

package/lib/types/dsh-adapter/team-roster.js

@@ -0,0 +1,136 @@
+/**
+ * Read side of DSH's experimental Agent Teams: the Lead session's `agentTeam`
+ * projection (roster + non-deleted task board), folded for the session on
+ * screen. Inside a teammate it reads the Lead's value, found through the
+ * teammate header's `parentSession` (another child of the Lead reads none).
+ *
+ * The wire value is narrowed locally (`@deepseek-ai/dsh-experimental-agent-team`
+ * is never imported); a composition without the team service never publishes
+ * the key and the store stays empty.
+ *
+ * @module
+ */
+import { attachSessionProjection, createSessionProjectionStore } from './session-projection-store.js';
+export const TEAM_PROJECTION_KEY = 'agentTeam';
+/** The upstream bundle that mounts the team service and tools: the team-mode switch. */
+export const TEAM_BUNDLE = '@deepseek-ai/dsh-experimental-agent-team-profile';
+const PHASES = new Set(['provisioning', 'active', 'failed']);
+const TASK_STATUSES = new Set(['pending', 'in_progress', 'completed']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'string');
+}
+function asMember(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { id, name, role, phase, error } = value;
+    if (typeof id !== 'string' || typeof name !== 'string')
+        return undefined;
+    if (role !== 'lead' && role !== 'teammate')
+        return undefined;
+    if (typeof phase !== 'string' || !PHASES.has(phase))
+        return undefined;
+    return { id, name, role, phase: phase, ...typeof error === 'string' ? { error } : {} };
+}
+function asTask(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { id, revision, subject, description, status, blockedBy, writeScopes, ownerName, ready, writeScopeWarnings } = value;
+    if (typeof id !== 'string' || typeof revision !== 'number' || typeof subject !== 'string' || typeof description !== 'string')
+        return undefined;
+    if (typeof status !== 'string' || !TASK_STATUSES.has(status))
+        return undefined;
+    if (!isStringArray(blockedBy) || !isStringArray(writeScopes) || !isStringArray(writeScopeWarnings) || typeof ready !== 'boolean')
+        return undefined;
+    return {
+        id, revision, subject, description, status: status, blockedBy, writeScopes, ready, writeScopeWarnings,
+        ...typeof ownerName === 'string' ? { ownerName } : {},
+    };
+}
+/**
+ * Narrow one `agentTeam` value into the view the UI renders. A session's
+ * implicit team (the Lead alone, no task, no failure) is no team: every root
+ * session publishes that baseline once the service is mounted.
+ * @param value - Raw projection value.
+ * @param leadSessionId - The session the value was published for.
+ * @returns the team view, or `undefined` when there is nothing to show.
+ */
+export function asTeamView(value, leadSessionId) {
+    if (!isRecord(value) || !Array.isArray(value.members) || !Array.isArray(value.tasks))
+        return undefined;
+    const members = value.members.map(asMember);
+    const tasks = value.tasks.map(asTask);
+    if (members.includes(undefined) || tasks.includes(undefined))
+        return undefined;
+    const failure = typeof value.failure === 'string' ? value.failure : undefined;
+    const roster = members;
+    const board = tasks;
+    if (!roster.some(member => member.role === 'teammate') && board.length === 0 && failure === undefined)
+        return undefined;
+    return { leadSessionId, members: roster, tasks: board, ...failure === undefined ? {} : { failure } };
+}
+/**
+ * The team a bound session belongs to is rooted at itself, or — for a
+ * delegated child — at its parent: teammates are direct children of the Lead.
+ * @param session - The bound session.
+ * @param agents - Live agents, to find the Lead's session object for a baseline.
+ * @returns the session whose `agentTeam` value to read.
+ */
+export function teamRootOf(session, agents) {
+    const own = session;
+    const parent = own.header?.origin === 'subagent' ? own.header.parentSession : undefined;
+    if (typeof parent !== 'string')
+        return { id: String(own.id), session };
+    for (const agent of agents?.list() ?? []) {
+        if (String(agent.session.id) === parent)
+            return { id: parent, session: agent.session };
+    }
+    return { id: parent };
+}
+/**
+ * The watched team as seen from `sessionId`: the Lead's own, or a listed
+ * teammate's. Any other child of the Lead (a plain subagent, a workflow
+ * spawn) is watched at the same parent but belongs to no team.
+ * @param team - The watched session's team.
+ * @param sessionId - The bound session.
+ * @returns the team, or `undefined` when the session is not on it.
+ */
+export function teamFor(team, sessionId) {
+    if (team === undefined || team.leadSessionId === sessionId)
+        return team;
+    return team.members.some(member => member.role === 'teammate' && member.id === sessionId) ? team : undefined;
+}
+/**
+ * Create the composition root's team store and wire it to the host.
+ * @param ctx - Host context of the composition root.
+ * @returns the store the channel reads from.
+ */
+export function createTeamRosterStore(ctx) {
+    const store = createSessionProjectionStore({
+        key: TEAM_PROJECTION_KEY,
+        // A team bundle switched off at run time takes the service down before
+        // (or while) its projection definition leaves: no service, no team.
+        narrow: (value, leadSessionId) => (ctx.get('agentTeams', false) === undefined ? undefined : asTeamView(value, leadSessionId)),
+        watch: session => teamRootOf(session, ctx.get('agents')),
+        warn: message => { ctx.logger.warn(message); },
+    });
+    attachSessionProjection(ctx, TEAM_PROJECTION_KEY, store);
+    // The plugin manager announces every profile write it applied (`/team`,
+    // `/plugin`, the Web UI). Unregistering a projection emits nothing on the
+    // change feed, so the bound session is read again: an unmounted team clears
+    // the view, a remounted one comes back from the Lead's log.
+    ctx.on('plugin-manager/changed', () => { store.reseed(); });
+    // Not every service change is announced there (an HMR-applied CLI or hand
+    // edit, a late or recovered activation), and the narrow reads the service:
+    // follow it directly. A service that comes back before its projection
+    // definition reads absent here; the manager event above reads it again.
+    ctx.on('internal/service', ((name) => {
+        if (name === 'agentTeams')
+            store.reseed();
+    }));
+    return Object.assign(store, {
+        teamOf: (sessionId) => (store.boundId === sessionId ? teamFor(store.read(), sessionId) : undefined),
+    });
+}

package/lib/types/dsh-adapter/team-tools.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Compact cards for DSH's experimental Agent Teams tools. Their results are
+ * compact JSON records and the tools ship no presenters, so the plain card
+ * would show a capitalised tool id and a raw `⎿ {"messageId":…}` line. These
+ * views fold known shapes into one line; anything else (an error text, a
+ * changed upstream shape) falls back to the plain card. A presenter the tool
+ * itself registers always wins: these run only when it has none.
+ * `spawn_teammate` is not here — it renders as the subagent row, and as a
+ * plain card only when it fails before the teammate exists (translate.ts).
+ *
+ * Three names are shared with the legacy subagent controls, which also ship
+ * no presenters: a team call is told apart by its `target` argument (the
+ * legacy ones take `agent_id`), a team result by its record shape.
+ *
+ * {@link teamMessageOf} reads a delivered team message for the transcript
+ * translator.
+ *
+ * @module
+ */
+import type { ToolCallView, ToolResultView } from './channel/types.js';
+/** The team's own delegation tool; its presence is what "team on" means to a request. */
+export declare const TEAM_SPAWN_TOOL = "spawn_teammate";
+/** Whether `name` is a team tool with a compact card here (not `spawn_teammate`). */
+export declare function isTeamToolName(name: string): boolean;
+/**
+ * Call card for a team tool without its own presenter.
+ * @param name - Tool name.
+ * @param rawArgs - The call's JSON arguments.
+ * @returns the card, or `undefined` when this is not a team tool call it knows.
+ */
+export declare function teamToolCallView(name: string, rawArgs: string): ToolCallView | undefined;
+/**
+ * Result card for a team tool without its own presenter. It replaces the
+ * call card, so it carries the call's title too.
+ * @param name - Tool name.
+ * @param rawArgs - The call's JSON arguments.
+ * @param text - The result's text content.
+ * @returns the card, or `undefined` for anything but a known result record.
+ */
+export declare function teamToolResultView(name: string, rawArgs: string, text: string): ToolResultView | undefined;
+/**
+ * An Agent Teams message delivered to a session (`user/message`): the
+ * generic relay (`agent-message` / `relay`) whose first block is exactly
+ * `Team message from <name>:`. A relay is any agent's message (the legacy
+ * `send_message` writes one too), so only the team's framing block marks it
+ * as a team message; the sender label replaces that block. The relay also
+ * reaches the agent-message feed, which owns it on a teammate's own pages;
+ * this reading is for the receiving transcript. A 0.2.0 log is read through
+ * `compat/agent-team-0.2.0.ts` first.
+ */
+export declare function teamMessageOf<B extends {
+    readonly type: string;
+}>(source: unknown, content: readonly B[]): {
+    sender: string;
+    blocks: readonly B[];
+    text: string;
+} | undefined;
+//# sourceMappingURL=team-tools.d.ts.map

package/lib/types/dsh-adapter/team-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-tools.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/team-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAgBtE,yFAAyF;AACzF,eAAO,MAAM,eAAe,mBAAmB,CAAA;AAE/C,qFAAqF;AACrF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AA4CD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAKxF;AAmDD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAa1G;AAKD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAgB7K"}

package/lib/types/dsh-adapter/team-tools.js

@@ -0,0 +1,208 @@
+/**
+ * Compact cards for DSH's experimental Agent Teams tools. Their results are
+ * compact JSON records and the tools ship no presenters, so the plain card
+ * would show a capitalised tool id and a raw `⎿ {"messageId":…}` line. These
+ * views fold known shapes into one line; anything else (an error text, a
+ * changed upstream shape) falls back to the plain card. A presenter the tool
+ * itself registers always wins: these run only when it has none.
+ * `spawn_teammate` is not here — it renders as the subagent row, and as a
+ * plain card only when it fails before the teammate exists (translate.ts).
+ *
+ * Three names are shared with the legacy subagent controls, which also ship
+ * no presenters: a team call is told apart by its `target` argument (the
+ * legacy ones take `agent_id`), a team result by its record shape.
+ *
+ * {@link teamMessageOf} reads a delivered team message for the transcript
+ * translator.
+ *
+ * @module
+ */
+import { agentRelaySourceOf } from '../agent/messages.js';
+import { legacySendMessageStatus } from './compat/agent-team-0.2.0.js';
+const DISPLAY_KEYS = {
+    send_message: 'tool-name-team-message',
+    list_agents: 'tool-name-team-roster',
+    wait_agent: 'tool-name-team-wait',
+    interrupt_agent: 'tool-name-team-interrupt',
+    team_task_create: 'tool-name-team-task',
+    team_task_list: 'tool-name-team-task',
+    team_task_get: 'tool-name-team-task',
+    team_task_update: 'tool-name-team-task',
+};
+/** The team's own delegation tool; its presence is what "team on" means to a request. */
+export const TEAM_SPAWN_TOOL = 'spawn_teammate';
+/** Whether `name` is a team tool with a compact card here (not `spawn_teammate`). */
+export function isTeamToolName(name) {
+    return DISPLAY_KEYS[name] !== undefined;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function str(value) {
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+function firstLine(text) {
+    return text.split('\n', 1)[0].trim();
+}
+function callTitle(name, args) {
+    switch (name) {
+        case 'send_message': {
+            const target = str(args.target);
+            if (target === undefined)
+                return undefined;
+            const message = str(args.message);
+            return message === undefined ? `→ ${target}` : `→ ${target} · ${firstLine(message)}`;
+        }
+        // `list_agents` / `wait_agent` calls carry nothing that tells them from the
+        // legacy subagent controls of the same names; only their results do.
+        case 'interrupt_agent':
+            return str(args.target);
+        case 'team_task_create':
+            return str(args.subject);
+        case 'team_task_list':
+            return ['status', 'owner', 'ready'].flatMap(key => (args[key] === undefined ? [] : [`${key}=${String(args[key])}`])).join(' ') || undefined;
+        case 'team_task_get':
+            return str(args.task_id);
+        case 'team_task_update': {
+            const id = str(args.task_id);
+            const action = str(args.action);
+            if (id === undefined || action === undefined)
+                return undefined;
+            const owner = str(args.owner);
+            return owner === undefined ? `${id} ${action}` : `${id} ${action} → ${owner}`;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Call card for a team tool without its own presenter.
+ * @param name - Tool name.
+ * @param rawArgs - The call's JSON arguments.
+ * @returns the card, or `undefined` when this is not a team tool call it knows.
+ */
+export function teamToolCallView(name, rawArgs) {
+    const displayKey = DISPLAY_KEYS[name];
+    if (displayKey === undefined)
+        return undefined;
+    const title = titleOf(name, rawArgs);
+    return title === undefined ? undefined : { card: 'generic', title, displayKey, category: 'other' };
+}
+function titleOf(name, rawArgs) {
+    let args;
+    try {
+        args = JSON.parse(rawArgs);
+    }
+    catch {
+        return undefined;
+    }
+    return isRecord(args) ? callTitle(name, args) : undefined;
+}
+function taskLine(task) {
+    const id = str(task.id);
+    const status = str(task.status);
+    if (id === undefined || status === undefined || typeof task.revision !== 'number')
+        return undefined;
+    const owner = str(task.ownerName);
+    return `${id} r${task.revision} · ${status}${owner === undefined ? '' : ` · ${owner}`}`;
+}
+function resultLine(name, value) {
+    switch (name) {
+        case 'send_message':
+            if (!isRecord(value))
+                return undefined;
+            if (value.sent === true)
+                return 'sent';
+            // compat(dsh 0.2.0, log): the mailbox status a 0.2.0 send answered.
+            return legacySendMessageStatus(value);
+        case 'list_agents': {
+            if (!Array.isArray(value))
+                return undefined;
+            const members = value.flatMap(member => (isRecord(member) && str(member.target) !== undefined && str(member.status) !== undefined
+                ? [`${String(member.target)} ${String(member.status)}`]
+                : []));
+            return members.length === value.length ? members.join(' · ') : undefined;
+        }
+        case 'wait_agent':
+            if (!isRecord(value) || typeof value.timedOut !== 'boolean')
+                return undefined;
+            if (value.noProgress)
+                return 'noProgress';
+            return value.timedOut ? 'timedOut' : 'changed';
+        case 'interrupt_agent':
+            return isRecord(value) ? str(value.previousStatus) : undefined;
+        case 'team_task_list': {
+            if (!isRecord(value) || !Array.isArray(value.tasks))
+                return undefined;
+            const tasks = value.tasks.map(task => (isRecord(task) ? taskLine(task) : undefined));
+            if (tasks.includes(undefined))
+                return undefined;
+            return tasks.join('\n');
+        }
+        case 'team_task_create':
+        case 'team_task_get':
+        case 'team_task_update':
+            return isRecord(value) ? taskLine(value) : undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Result card for a team tool without its own presenter. It replaces the
+ * call card, so it carries the call's title too.
+ * @param name - Tool name.
+ * @param rawArgs - The call's JSON arguments.
+ * @param text - The result's text content.
+ * @returns the card, or `undefined` for anything but a known result record.
+ */
+export function teamToolResultView(name, rawArgs, text) {
+    const displayKey = DISPLAY_KEYS[name];
+    if (displayKey === undefined || !text.startsWith('{') && !text.startsWith('['))
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    const line = resultLine(name, value);
+    if (line === undefined)
+        return undefined;
+    const title = titleOf(name, rawArgs);
+    return {
+        card: 'generic', displayKey, category: 'other',
+        ...title === undefined || title === '' ? {} : { title },
+        content: line === '' ? [] : line.split('\n').map(text => ({ type: 'text', text })),
+    };
+}
+/** Relay framing: one whole leading block, `Team message from <name>:`. */
+const RELAY_FRAMING = /^Team message from ([^\n]+):$/;
+/**
+ * An Agent Teams message delivered to a session (`user/message`): the
+ * generic relay (`agent-message` / `relay`) whose first block is exactly
+ * `Team message from <name>:`. A relay is any agent's message (the legacy
+ * `send_message` writes one too), so only the team's framing block marks it
+ * as a team message; the sender label replaces that block. The relay also
+ * reaches the agent-message feed, which owns it on a teammate's own pages;
+ * this reading is for the receiving transcript. A 0.2.0 log is read through
+ * `compat/agent-team-0.2.0.ts` first.
+ */
+export function teamMessageOf(source, content) {
+    const first = content[0];
+    const framing = agentRelaySourceOf(source) !== undefined && first?.type === 'text' && typeof first.text === 'string'
+        ? RELAY_FRAMING.exec(first.text)
+        : null;
+    if (framing === null)
+        return undefined;
+    const sender = framing[1];
+    const blocks = content.slice(1);
+    const text = blocks
+        .flatMap(block => {
+        const value = block.text;
+        return block.type === 'text' && typeof value === 'string' ? [value] : [];
+    })
+        .join('\n')
+        .trim();
+    return { sender, blocks, text };
+}