agenthub-multiagent-mcp 1.51.0 → 1.53.0

package/dist/streamingRuntimeLib.d.ts

@@ -0,0 +1,391 @@
+/**
+ * Pure helpers for the employee streaming runtime (add-employee-streaming-runtime).
+ *
+ * Extracted from streamingRuntime.ts so the auth assert, inbound-message decision
+ * (self-filter / non-actionable / dedup), turn rendering, and context-recycle
+ * decision are unit-testable without an SDK subprocess or a live WebSocket.
+ *
+ * Verified premise (VPS spike 2026-06-26, org brain #2209): the Claude Agent SDK
+ * streaming mode runs on the subscription (CLAUDE_CODE_OAUTH_TOKEN, no
+ * ANTHROPIC_API_KEY) and processes a mid-run yielded message in the same session.
+ *
+ * ---------------------------------------------------------------------------
+ * CANONICAL COPY — `employee-runtime/src/streamingRuntimeLib.ts` is vendored
+ * from this file and must stay **functionally** in sync (add-multiplayer-sessions
+ * §2.4). Change one, change the other in the same commit.
+ *
+ * Why two copies rather than an import: `employee-runtime` is a separate package
+ * precisely because the agent-sdk's peer deps conflict with this package's, so it
+ * cannot depend on `agenthub-multiagent-mcp`. The daemon side imports this copy
+ * (for the `streamingEnabled()` gate); the runtime imports the vendored one.
+ *
+ * The two headers differ, and the vendored copy carries fewer prose comments;
+ * everything below the header is expected to be identical. Keep it import-free —
+ * pure logic only — so neither copy drags a package-specific dependency across.
+ * ---------------------------------------------------------------------------
+ */
+export interface AgentMessage {
+    id: string;
+    from_agent: string;
+    to_agent?: string;
+    type?: string;
+    subject?: string;
+    body: string;
+    priority?: string;
+}
+/** A handled-id lookup (the surface of HandledMessageStore we depend on). */
+export interface HandledLookup {
+    has(id: string): boolean;
+}
+/** §2.1 — the streaming runtime is OFF unless explicitly enabled. */
+export declare function streamingEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Human steering kill switch (add-multiplayer-sessions §4.8). Default **off** —
+ * unset, empty, or unrecognised means disabled, and while it is off the producer
+ * side does no I/O at all: no transport is declared, nothing is polled, and the
+ * runtime loop is what it was before this feature existed.
+ *
+ * It lives here rather than in a runtime-only module because both producers
+ * consult it: the streaming runtime (which declares `turn_queue` and pulls
+ * steers) and the one-shot daemon (which declares `one_shot` so its shifts are
+ * refused explicitly rather than by accident of having declared nothing).
+ * Mirrors the server's `AGENTHUB_SESSION_STEER_ENABLED`; a producer that polled
+ * while the server had it off would earn a 503 on every tick.
+ */
+export declare function sessionSteerEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * §D3 — assert subscription auth and fail CLOSED against metered billing. The
+ * SDK subprocess inherits the env; if ANTHROPIC_API_KEY were set it would take
+ * precedence over the subscription token, so we refuse to start.
+ */
+export declare function assertSubscriptionAuth(env?: NodeJS.ProcessEnv): {
+    oauthToken: string;
+};
+export interface InboundDecision {
+    /** Whether this event should be yielded into the session as a turn. */
+    yield: boolean;
+    reason?: "not-a-message" | "no-id" | "self" | "non-actionable" | "duplicate";
+    message?: AgentMessage;
+}
+/**
+ * Decide whether a raw WS event becomes a session turn. Mirrors the one-shot
+ * daemon's at-most-once guards: ignore self-messages, never auto-act on
+ * `response`/`status` (loop-safety), and dedup against handled ids. The caller
+ * ACKs regardless and records handled ids.
+ */
+export declare function decideInbound(envelope: unknown, agentId: string, handled: HandledLookup): InboundDecision;
+/**
+ * The message type a human steer arrives as. Mirrors `sessions.SteerMessageType`
+ * on the server, which validates it on the way in — an unrecognised type would be
+ * persisted and then framed by whatever branch this function fell through to,
+ * which is the same silent-wrong-behaviour class as a dropped steer.
+ */
+export declare const STEER_MESSAGE_TYPE = "steer";
+/**
+ * Render an AgentHub message as the text content of a session turn.
+ *
+ * Two framings, and the distinction is the whole point of §4.3. An inbox message
+ * is agent-to-agent: somebody is waiting on an answer, so the turn tells the
+ * model to answer with `mcp__agenthub__reply`. A steer is a human leaning over
+ * the session and redirecting the work: nobody is waiting on a message, and
+ * telling the model to reply would turn "stop rewriting that file" into a note
+ * written back to the person who typed it while the work carried on unchanged.
+ */
+export declare function buildTurnContent(m: AgentMessage): string;
+/**
+ * Frame a steer as what it is: a direct instruction from a human operator
+ * watching this session (§4.3).
+ *
+ * Deliberately parallel to `buildInstructionTurnContent` in `workstation.ts`,
+ * which solves the same problem for a driven personal workspace. Both say the
+ * same three things, because all three are load-bearing: who this came from, that
+ * it is an instruction rather than correspondence, and that no reply is wanted.
+ * The refusal clause is here for the same reason it is there — a human can steer
+ * a session into something the agent should not do, and "say so and stop" is a
+ * better outcome than either silent compliance or silent refusal.
+ */
+export declare function buildSteerTurnContent(m: AgentMessage): string;
+/** A `session_steer` frame pushed over the per-agent WebSocket. */
+export interface SteerFrame {
+    sessionId: string;
+    steerId: string;
+    text: string;
+    createdBy: string;
+    messageType: string;
+}
+/**
+ * Parse a `session_steer` WebSocket frame (the channel transport's delivery
+ * path). Returns `null` for anything that is not a well-formed steer.
+ *
+ * Lives here rather than in the channel plugin because the plugin is an
+ * executable script — importing it to test it would start an MCP server — and
+ * because the frame is a wire contract shared with the server, which is the kind
+ * of thing that should have one parser and one test.
+ *
+ * A frame missing an id or text is `null` rather than a partially-populated
+ * steer: an instruction with no text delivers nothing, and one with no id cannot
+ * be acked, so "deliver it anyway" would produce exactly the accepted-and-dropped
+ * outcome the whole transport contract exists to rule out.
+ */
+export declare function parseSteerFrame(envelope: unknown): SteerFrame | null;
+/** The SDK streaming-input user message shape (proven in the spike). */
+export interface SDKUserTurn {
+    type: "user";
+    message: {
+        role: "user";
+        content: string;
+    };
+    parent_tool_use_id: null;
+    session_id: string;
+}
+export declare function toUserTurn(content: string, sessionId: string): SDKUserTurn;
+export interface RecycleOptions {
+    /** Recycle the session after this many turns. */
+    maxTurns: number;
+    /** Recycle once cumulative input tokens cross this budget. */
+    tokenBudget: number;
+}
+export interface RecycleState {
+    turns: number;
+    estInputTokens: number;
+}
+export declare function defaultRecycleOptions(env?: NodeJS.ProcessEnv): RecycleOptions;
+/**
+ * §D4 — recycle the kept-alive session once it has run enough turns or
+ * accumulated enough input-token context, to bound Max-cap consumption. The
+ * caller starts a fresh session (carrying a short summary) on `true`.
+ */
+export declare function shouldRecycle(state: RecycleState, opts: RecycleOptions): boolean;
+/**
+ * Cumulative counters for one runtime process. Unlike RecycleState (which resets
+ * per session to drive the recycle threshold), these survive session recycles and
+ * describe the employee's whole run — surfaced via a `/usage`-style log line for
+ * operators and the trainer.
+ */
+export interface RuntimeStats {
+    turns: number;
+    estInputTokens: number;
+    estOutputTokens: number;
+    sessionRecycles: number;
+    reconnects: number;
+    dedupHits: number;
+}
+export declare function newRuntimeStats(): RuntimeStats;
+/**
+ * Fold one SDK `result` message's usage into the cumulative stats (mutates + returns).
+ * estInputTokens counts fresh + cache-read + cache-creation input (matching the
+ * recycle accounting); estOutputTokens is the generated output.
+ */
+export declare function recordResultUsage(stats: RuntimeStats, usage: Record<string, number> | undefined): RuntimeStats;
+/**
+ * A `/usage`-style structured one-liner for the runtime log — a single greppable
+ * line (log-exporter / Loki friendly). Native Prometheus is deliberately deferred
+ * (§4.2): the one-shot daemon exposes no metrics series to mirror, so a scrapable
+ * log line is the sensible surface for a default-off feature.
+ */
+export declare function formatUsageLine(agentId: string, stats: RuntimeStats, uptimeSec: number): string;
+export interface InSessionMcpEnvOpts {
+    apiUrl: string;
+    apiKey: string;
+    agentId: string;
+    userApiKey?: string;
+}
+/**
+ * Env for the in-session MCP the streaming runtime launches. Critically sets
+ * `AGENTHUB_HEADLESS=true`: without it, a failed startup reconnect routes the
+ * model to `agent_register`, which polls a browser-confirm flow for 10 min
+ * (3000ms × 200) that nobody can complete in a headless SDK subprocess — the
+ * observed ~7-min stall (§3). Headless routes `agent_register` to the fast,
+ * non-interactive register instead. A user API key (when the daemon has one) is
+ * passed through so any such fallback register is coherent and user-owned rather
+ * than a browser round-trip.
+ */
+export declare function inSessionMcpEnv(opts: InSessionMcpEnvOpts): Record<string, string>;
+/**
+ * Fail-fast identity guard the runtime previously lacked. The daemon establishes
+ * the worker connect token in the workspace's `.agenthub/state` before handing
+ * off (and reconnect is a pure re-attach server-side, so the in-session MCP
+ * safely shares it). If that state is absent the hand-off is broken; refuse to
+ * start sessions (throw → `main()` exits non-zero → the daemon restarts and
+ * re-heals identity) rather than letting the in-session MCP hang on registration.
+ */
+export declare function assertWorkerIdentityReady(stateExists: boolean, agentId: string): void;
+/**
+ * One row of `POST /api/sessions/{id}/events`.
+ *
+ * `payload` is a JSON **string**, not an object — that is the wire contract the
+ * server and `session-capture.sh` already share, and the dashboard `JSON.parse`s
+ * it per event. Do not "improve" it into a nested object; both producers and the
+ * reader would have to change together.
+ */
+export interface SessionEvent {
+    event_type: string;
+    payload: string;
+    token_count: number;
+}
+/** One content block inside an SDK message. Every field optional — see SDKStreamMessage. */
+export interface SDKContentBlock {
+    type?: string;
+    /** `text` blocks */
+    text?: string;
+    /** `tool_use` blocks */
+    id?: string;
+    name?: string;
+    input?: unknown;
+    /** `tool_result` blocks */
+    tool_use_id?: string;
+    content?: unknown;
+    is_error?: boolean;
+}
+/**
+ * Structural view of one Agent SDK stream message (§2.1).
+ *
+ * The runtime loop used to cast the stream to `{ type?, usage? }`, which is why
+ * assistant text and tool traffic were never observable: the content was not
+ * modelled, so there was nothing downstream to read. This widens the model to
+ * the parts we consume.
+ *
+ * Deliberately structural rather than the SDK's own `SDKMessage`: this module is
+ * vendored into the mcp-server package, which does not (and must not) depend on
+ * `@anthropic-ai/claude-agent-sdk`. Every field is optional so an unrecognised
+ * or newly-added SDK message shape degrades to "no events" instead of throwing
+ * inside the runtime's hot loop.
+ */
+export interface SDKStreamMessage {
+    type?: string;
+    usage?: Record<string, number>;
+    message?: {
+        role?: string;
+        content?: string | SDKContentBlock[];
+    };
+    parent_tool_use_id?: string | null;
+    session_id?: string;
+}
+/**
+ * Client-side payload bounds. The server is authoritative for truncation and
+ * redaction (add-multiplayer-sessions §1.8/§1.9) and this code deliberately does
+ * **not** duplicate either. These bounds exist only so a single event is never
+ * megabytes on the wire; they mirror `session-capture.sh`'s TRUNC / TRUNC_SHORT
+ * so both producers put comparable volumes in front of the same server pipeline.
+ */
+export declare const PAYLOAD_MAX_CHARS = 8000;
+export declare const PAYLOAD_SUMMARY_MAX_CHARS = 1000;
+/**
+ * Turn SDK stream messages into session events (§2.2).
+ *
+ * The event vocabulary is exactly the one `session-capture.sh` already produces
+ * (`assistant_message`, `command_exec`, `file_read`, `file_edit`, `file_write`,
+ * `tool_call`) so the dashboard renders hook-captured and runtime-captured
+ * sessions identically. No new event types are introduced here.
+ *
+ * One deliberate difference from the hook: the hook runs PostToolUse and so sees
+ * a tool's input and response together, emitting a single merged event. The
+ * stream delivers them as two separate messages (`tool_use` on the assistant
+ * message, `tool_result` on the following user message), so this emits two
+ * events. The class is stateful only to carry `tool_use_id → tool name` across
+ * that gap, so the result event can name the tool it belongs to. The map is
+ * bounded: a long session must not accumulate ids forever.
+ */
+export declare class SessionEventExtractor {
+    private readonly toolNames;
+    private readonly maxCorrelations;
+    constructor(maxCorrelations?: number);
+    extract(message: unknown): SessionEvent[];
+    private blocks;
+    private fromAssistant;
+    private fromToolResults;
+    private rememberTool;
+}
+/**
+ * The I/O the emitter needs, injected so the batching/lifecycle logic below is
+ * testable without a server and so this module stays free of transport imports
+ * (it is vendored into a package that has no session-capture client).
+ */
+export interface SessionEventTransport {
+    /** Create the coding session events are recorded under. `null` → run uncaptured. */
+    open(): Promise<string | null>;
+    post(sessionId: string, events: readonly SessionEvent[]): Promise<void>;
+    close(sessionId: string, reason: string): Promise<void>;
+}
+export interface SessionEventEmitterOptions {
+    transport: SessionEventTransport;
+    /** `false` → a hard no-op: no session is opened and nothing is posted. */
+    enabled: boolean;
+    /** Flush as soon as this many events are pending. */
+    maxBatch?: number;
+    /** Flush a partial batch after this long, so a quiet session still streams. */
+    flushIntervalMs?: number;
+    /** Hard bound on the unsent backlog; events beyond it are dropped, not buffered. */
+    maxPending?: number;
+    /**
+     * Called once, with the session id, the moment the captured session is created.
+     *
+     * Exists because the open is lazy (see below): the session id does not exist at
+     * construction, so anything that needs it — steering declares its transport
+     * here (§4.5) — would otherwise have to poll `currentSessionId`. A callback is
+     * the earliest that id can possibly be known, and "as early as the session id
+     * is known" is the requirement.
+     *
+     * A throwing listener is caught and logged: capture must not be breakable by a
+     * consumer of its lifecycle.
+     */
+    onOpen?: (sessionId: string) => void;
+    log?: (msg: string) => void;
+}
+/**
+ * Batches session events and owns the captured session's lifecycle (§2.3).
+ *
+ * Why batching: a chatty turn emits an event per text block and per tool call.
+ * One HTTP request each would put the runtime's throughput at the mercy of
+ * network latency and would trip the server's per-session rate cap on volume
+ * that is really one turn. Events are flushed when `maxBatch` accumulates, when
+ * `flushIntervalMs` elapses, and unconditionally at turn end and session end, so
+ * the tail of a conversation is never left sitting in the buffer.
+ *
+ * Why lazy open: the session is created on the first event rather than at
+ * construction, so an idle employee (the common case — the runtime blocks on the
+ * turn queue) creates nothing, and a runtime that crash-loops before producing
+ * output does not create a session per retry.
+ *
+ * Everything here is fail-soft, matching `sessionCapture.ts`: a failed create
+ * degrades the whole session to uncaptured (`failed` state, no retry storm), a
+ * failed post drops that batch, and no method ever throws. Capture is
+ * observability; it must never take down real work.
+ */
+export declare class SessionEventEmitter {
+    private readonly transport;
+    private readonly enabled;
+    private readonly maxBatch;
+    private readonly flushIntervalMs;
+    private readonly maxPending;
+    private readonly onOpen;
+    private readonly log;
+    private pending;
+    private state;
+    private openSessionId;
+    private timer;
+    private chain;
+    private dropped;
+    private dropWarned;
+    constructor(opts: SessionEventEmitterOptions);
+    /** The session events are being recorded under, or `null` before/after capture. */
+    get currentSessionId(): string | null;
+    get pendingCount(): number;
+    get droppedCount(): number;
+    /** Queue events. Synchronous and non-throwing — safe to call from the stream loop. */
+    emit(events: readonly SessionEvent[]): void;
+    /** Send everything pending now. Awaits the in-flight post; never throws. */
+    flush(): Promise<void>;
+    /**
+     * Flush the tail and close the captured session. After this the emitter is
+     * inert — a late `emit` from a straggling stream message is discarded rather
+     * than reopening a session nobody is watching.
+     */
+    end(reason: string): Promise<void>;
+    private schedule;
+    private clearTimer;
+    /** Serialized: posts must not race, or the server assigns sequence numbers out of order. */
+    private drain;
+    private drainOnce;
+}
+//# sourceMappingURL=streamingRuntimeLib.d.ts.map

package/dist/streamingRuntimeLib.d.ts.map

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