@compose-market/sdk 0.8.3 → 0.8.5

package/dist/resources/agent.js

@@ -1,28 +1,20 @@
 /**
  * Compose agent runtime stream resource.
  *
- * Subscribes to POST /agent/:wallet/stream on the Compose runtime service
- * and yields ordered model/activity events. The runtime emits OpenAI-ish
- * chat.completion.chunk frames for text deltas AND Compose-native frames
- * (`thinking_start`, `thinking_end`, `tool_start`, `tool_end`, `done`,
- * `error`). This resource normalises both into the single
- * text frames for chat content and Compose-native activity frames for
- * execution lifecycle. This resource keeps those domains separate.
+ * SDK responsibilities ONLY:
+ *   - HTTP request with payment/auth/abort
+ *   - Response header extraction (budget, receipt, session)
+ *   - EventBus emission (toolCallStart/End, childAgent*, planProposed, etc.)
+ *   - Text accumulation for final result
+ *   - Stream lifecycle (agentStreamStart/End)
  *
- * Integrates with:
- *   - `sdk.events.toolCallStart` / `toolCallEnd` — emitted whenever the
- *     runtime tool vocabulary fires, so UI strips can react uniformly
- *     regardless of whether the source is agent, workflow, or chat.
- *   - `sdk.events.agentStreamStart` / `agentStreamEnd` — lifecycle notifications.
- *   - `instrumentBillableResponse` — budget/receipt/sessionInvalid surfaced
- *     exactly as on every other billable SDK call.
+ * All SSE protocol, decoding, and event type routing is delegated to
+ * @compose-market/core/sse/stream — the single source of truth.
  */
 import { Error } from "../errors.js";
-import { parseSSEStream } from "@compose-market/core/transport";
-import { extractReceiptFromResponse, parseReceiptEvent } from "@compose-market/core/sse/receipt";
+import { streamEvents } from "@compose-market/core/sse/stream";
+import { extractReceiptFromResponse } from "@compose-market/core/sse/receipt";
 import { extractSessionBudgetFromResponse } from "@compose-market/core/sse/budget";
-import { decode as decodeActivityEvent } from "@compose-market/core/activity";
-import { decode as decodeModelEvent } from "@compose-market/core/model";
 import { buildCallHeaders, StreamIterator, requestResponseWithPayment, } from "./inference.js";
 export class AgentResource {
     ctx;
@@ -32,11 +24,6 @@ export class AgentResource {
     stream(params, options = {}) {
         return new StreamIterator(driveAgentStream(this.ctx, params, options));
     }
-    /**
-     * Abort an in-flight stream for (agentWallet, runId). Conversation/CoT/memory
-     * for the thread are preserved by the LangGraph checkpoint and can be resumed
-     * by issuing a new stream call with the same threadId.
-     */
     async stop(params) {
         const wallet = this.ctx.getWalletMaybe();
         const token = this.ctx.getTokenMaybe();
@@ -74,7 +61,7 @@ export class AgentResource {
         if (wallet.chainId !== null)
             headers["x-chain-id"] = String(wallet.chainId);
         const path = `/agent/${encodeURIComponent(params.agentWallet)}/runs/${encodeURIComponent(params.runId)}/approval`;
-        return await this.ctx.http.request({
+        const response = await this.ctx.http.request({
             method: "POST",
             path,
             headers,
@@ -84,12 +71,16 @@ export class AgentResource {
                 decision: params.decision,
                 ...(params.approvalId ? { approvalId: params.approvalId } : {}),
                 ...(params.approver ? { approver: params.approver } : {}),
-                ...(params.reason ? { reason: params.reason } : {}),
                 ...(params.feedback ? { feedback: params.feedback } : {}),
+                ...(params.reason ? { reason: params.reason } : {}),
             },
-        });
+        }).withResponse();
+        return { approved: Boolean(response.data?.approved) };
     }
 }
+// =============================================================================
+// Stream Driver — HTTP + EventBus + text accumulation only
+// =============================================================================
 async function* driveAgentStream(ctx, params, options) {
     const path = `/agent/${encodeURIComponent(params.agentWallet)}/stream`;
     const wallet = ctx.getWalletMaybe();
@@ -203,285 +194,32 @@ async function* driveAgentStream(ctx, params, options) {
     }
     let text = "";
     let streamReceipt = null;
-    let emittedDone = false;
-    const postDoneTimeoutMs = options.paymentMode === "x402" ? 90_000 : 250;
     const toolCalls = [];
-    const activeTools = new Map();
-    const decodeOptions = { runId: params.runId };
+    const stream = streamEvents(response.body, {
+        runId: params.runId,
+        signal: options.signal,
+    });
     try {
-        const sse = parseSSEStream(response.body, { signal: options.signal })[Symbol.asyncIterator]();
+        let result;
         while (true) {
-            const next = await readAgentStreamFrame(sse, emittedDone ? postDoneTimeoutMs : undefined);
-            if (next.done)
+            const next = await stream.next();
+            if (next.done) {
+                result = next.value;
                 break;
-            const frame = next.value;
-            if (frame.data === "[DONE]") {
-                if (!emittedDone) {
-                    emittedDone = true;
-                }
-                continue;
-            }
-            if (isReceiptEvent(frame.event)) {
-                try {
-                    streamReceipt = parseReceiptEvent(frame.data);
-                    ctx.events.emit("receipt", {
-                        userAddress: wallet.address,
-                        chainId: wallet.chainId,
-                        receipt: streamReceipt,
-                        requestId,
-                        source: "stream",
-                    });
-                }
-                catch { /* skip malformed */ }
-                if (emittedDone)
-                    break;
-                continue;
-            }
-            if (frame.event === "compose.error") {
-                const decoded = decodeActivityEvent(frame, decodeOptions)
-                    ?? decodeActivityEvent({ type: "error", message: frame.data }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (!frame.data)
-                continue;
-            if (emittedDone)
-                continue;
-            let payload = null;
-            try {
-                payload = JSON.parse(frame.data);
-            }
-            catch {
-                const delta = frame.data;
-                text += delta;
-                const decoded = decodeModelEvent(delta, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (payload.domain === "model") {
-                const decoded = decodeModelEvent(payload, decodeOptions);
-                if (decoded) {
-                    if (decoded.type === "model.text.delta" && decoded.delta)
-                        text += decoded.delta;
-                    if (decoded.type === "model.text.done" && decoded.text && !text)
-                        text = decoded.text;
-                    yield decoded;
-                }
-                continue;
-            }
-            if (payload.domain === "activity") {
-                const decoded = decodeActivityEvent(payload, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            // OpenAI chat.completion.chunk passthrough — runtime forwards these
-            // for streamed assistant text.
-            const choices = Array.isArray(payload.choices) ? payload.choices : null;
-            if (choices && choices.length > 0) {
-                const delta = choices[0].delta;
-                const reasoningChunk = typeof delta?.reasoning_content === "string"
-                    ? delta.reasoning_content
-                    : null;
-                if (reasoningChunk) {
-                    const decoded = decodeModelEvent({ type: "reasoning-delta", delta: reasoningChunk }, decodeOptions);
-                    if (decoded)
-                        yield decoded;
-                }
-                const streamedChunk = typeof delta?.content === "string"
-                    ? delta.content
-                    : null;
-                if (streamedChunk) {
-                    text += streamedChunk;
-                    const decoded = decodeModelEvent({ type: "text-delta", delta: streamedChunk }, decodeOptions);
-                    if (decoded)
-                        yield decoded;
-                }
-                continue;
-            }
-            const type = typeof payload.type === "string" ? payload.type : "";
-            const proposalFrame = proposal(payload, type);
-            if (proposalFrame) {
-                emitProposal(ctx.events, wallet, requestId, proposalFrame);
-                const decoded = decodeActivityEvent(proposalFrame, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            const childFrame = child(payload, type);
-            if (childFrame) {
-                emitChild(ctx.events, wallet, requestId, childFrame);
-                const decoded = decodeActivityEvent(childFrame, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            const traceFrame = trace(payload, type);
-            if (traceFrame) {
-                const decoded = decodeActivityEvent(traceFrame, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            const conclaveFrame = conclave(payload, type);
-            if (conclaveFrame) {
-                const decoded = decodeActivityEvent(conclaveFrame, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "thinking_start") {
-                const decoded = decodeActivityEvent(payload, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "thinking_end") {
-                const decoded = decodeActivityEvent(payload, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "reasoning_delta") {
-                const delta = typeof payload.delta === "string"
-                    ? payload.delta
-                    : typeof payload.content === "string"
-                        ? payload.content
-                        : "";
-                if (delta) {
-                    const decoded = decodeModelEvent({ type: "reasoning-delta", delta }, decodeOptions);
-                    if (decoded)
-                        yield decoded;
-                }
-                continue;
-            }
-            if (type === "tool_args_delta") {
-                const argsDelta = typeof payload.argsDelta === "string"
-                    ? payload.argsDelta
-                    : typeof payload.delta === "string"
-                        ? payload.delta
-                        : "";
-                if (argsDelta) {
-                    const id = typeof payload.id === "string" ? payload.id : undefined;
-                    const toolName = typeof payload.toolName === "string" ? payload.toolName : undefined;
-                    const decoded = decodeModelEvent({ type: "tool_args_delta", id, toolName, argsDelta }, decodeOptions);
-                    if (decoded)
-                        yield decoded;
-                }
-                continue;
             }
-            if (type === "stopped") {
-                const reason = typeof payload.reason === "string" ? payload.reason : "user_stop";
-                const decoded = decodeActivityEvent({ type: "stopped", reason }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "tool_start") {
-                const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
-                const summary = typeof payload.content === "string" ? payload.content : undefined;
-                const content = typeof payload.content === "string" ? payload.content : undefined;
-                const meta = view(payload.display);
-                const shown = {
-                    ...(meta?.name ? { displayName: meta.name } : {}),
-                    ...(meta ? { display: meta, targetKind: meta.kind } : {}),
-                    ...(meta?.target ? { target: meta.target } : {}),
-                };
-                activeTools.set(toolName, { summary });
-                ctx.events.emit("toolCallStart", {
-                    userAddress: wallet.address,
-                    chainId: wallet.chainId,
-                    requestId,
-                    source: "agent",
-                    toolCallId: toolName,
-                    toolName,
-                    ...shown,
-                    summary,
-                });
-                const decoded = decodeActivityEvent({ type: "tool-start", toolName, display: meta, summary, content, input: payload.input }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "tool_end") {
-                const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
-                const summary = typeof payload.message === "string" ? payload.message : undefined;
-                const failed = typeof payload.error === "string" && payload.error.length > 0;
-                const error = failed ? payload.error : undefined;
-                const meta = view(payload.display);
-                const displayName = meta?.name ?? display(toolName, payload);
-                const shown = {
-                    ...(displayName ? { displayName } : {}),
-                    ...(meta ? { display: meta, targetKind: meta.kind } : {}),
-                    ...(meta?.target ? { target: meta.target } : {}),
-                };
-                toolCalls.push({ toolName, ...shown, summary, failed, error });
-                activeTools.delete(toolName);
-                ctx.events.emit("toolCallEnd", {
-                    userAddress: wallet.address,
-                    chainId: wallet.chainId,
-                    requestId,
-                    source: "agent",
-                    toolCallId: toolName,
-                    toolName,
-                    ...shown,
-                    summary,
-                    failed,
-                    error,
-                });
-                const decoded = decodeActivityEvent({
-                    type: "tool-end",
-                    toolName,
-                    display: meta,
-                    summary,
-                    failed,
-                    error,
-                    output: payload.output ?? payload.message,
-                }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "error") {
-                const code = typeof payload.code === "string" ? payload.code : undefined;
-                const message = typeof payload.content === "string"
-                    ? payload.content
-                    : typeof payload.error === "string"
-                        ? payload.error
-                        : typeof payload.message === "string"
-                            ? payload.message
-                            : "Agent stream failed";
-                const decoded = decodeActivityEvent({ type: "error", code, message }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (type === "done") {
-                if (!emittedDone) {
-                    emittedDone = true;
-                    const decoded = decodeActivityEvent(payload, decodeOptions);
-                    if (decoded)
-                        yield decoded;
-                }
-                continue;
-            }
-            if (typeof payload.content === "string") {
-                text += payload.content;
-                const decoded = decodeModelEvent({ type: "text-delta", delta: payload.content }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (typeof payload.text === "string") {
-                text += payload.text;
-                const decoded = decodeModelEvent({ type: "text-delta", delta: payload.text }, decodeOptions);
-                if (decoded)
-                    yield decoded;
-                continue;
+            const event = next.value;
+            yield event;
+            handleEvent(event, ctx.events, wallet, requestId, { text, toolCalls });
+            if (event.domain === "model") {
+                const me = event;
+                if (me.type === "model.text.delta" && me.delta)
+                    text += me.delta;
+                if (me.type === "model.text.done" && me.text && !text)
+                    text = me.text;
             }
         }
+        if (result?.receipt)
+            streamReceipt = result.receipt;
     }
     finally {
         try {
@@ -497,221 +235,182 @@ async function* driveAgentStream(ctx, params, options) {
             runId: params.runId,
         });
     }
-    const finalReceipt = streamReceipt ?? headerReceipt;
     return {
         text,
         toolCalls,
         requestId,
-        receipt: finalReceipt,
+        receipt: streamReceipt ?? headerReceipt,
         budget,
         sessionInvalidReason,
     };
 }
-function isReceiptEvent(event) {
-    return event === "receipt" || event === "compose.receipt";
-}
-function obj(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function str(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function num(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function strings(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === "string")
-        ? value
-        : undefined;
-}
-function childKind(type) {
-    switch (type) {
-        case "swarm_child_start":
-            return "start";
-        case "swarm_child_delta":
-            return "delta";
-        case "swarm_child_tool_start":
-            return "tool-start";
-        case "swarm_child_tool_end":
-            return "tool-end";
-        case "swarm_child_done":
-            return "done";
-        case "swarm_child_error":
-            return "error";
-        default:
-            return null;
+function handleEvent(event, events, wallet, requestId, ctx) {
+    if (event.domain === "activity") {
+        handleActivityEvent(event, events, wallet, requestId, ctx);
     }
 }
-function view(value) {
-    const record = obj(value);
-    if (!record)
-        return undefined;
-    const kind = str(record.kind);
-    if (!kind || !["tool", "model", "connector", "agent", "search", "harness", "swarm", "conclave", "route"].includes(kind)) {
-        return undefined;
+function handleActivityEvent(event, events, wallet, requestId, ctx) {
+    const rawType = rawString(event.raw, "type") ?? "";
+    if (event.type === "activity.tool") {
+        handleToolEvent(event, events, wallet, requestId, ctx, rawType);
+        return;
+    }
+    if (event.type === "activity.child") {
+        handleChildEvent(event, events, wallet, requestId, rawType);
+        return;
+    }
+    if (event.type === "activity.plan") {
+        handlePlanEvent(event, events, wallet, requestId, rawType);
+        return;
     }
-    const details = obj(record.details);
-    return {
-        kind: kind,
-        ...(str(record.id) ? { id: str(record.id) } : {}),
-        ...(str(record.name) ? { name: str(record.name) } : {}),
-        ...(str(record.target) ? { target: str(record.target) } : {}),
-        ...(str(record.summary) ? { summary: str(record.summary) } : {}),
-        ...(details ? { details } : {}),
-    };
-}
-function decision(value) {
-    return value === "approved" || value === "rejected" || value === "changes_requested"
-        ? value
-        : undefined;
-}
-function proposal(payload, type) {
-    if (type !== "plan.proposed" && type !== "approval.requested" && type !== "approval.decided" && type !== "plan.feedback_requested")
-        return null;
-    const proposalId = str(payload.proposalId);
-    const version = num(payload.version);
-    const state = str(payload.state);
-    if (!proposalId || version === undefined || !state)
-        return null;
-    const details = obj(payload.details);
-    return {
-        type,
-        proposalId,
-        version,
-        state,
-        ...(decision(payload.decision) ? { decision: decision(payload.decision) } : {}),
-        ...(str(payload.rootRunId) ? { rootRunId: str(payload.rootRunId) } : {}),
-        ...(str(payload.runId) ? { runId: str(payload.runId) } : {}),
-        ...(str(payload.requestedBy) ? { requestedBy: str(payload.requestedBy) } : {}),
-        ...("proposal" in payload ? { proposal: payload.proposal } : {}),
-        ...(str(payload.markdown) ? { markdown: str(payload.markdown) } : {}),
-        ...(num(payload.ts) !== undefined ? { ts: num(payload.ts) } : {}),
-        ...(num(payload.updatedAt) !== undefined ? { updatedAt: num(payload.updatedAt) } : {}),
-        ...(str(payload.approver) ? { approver: str(payload.approver) } : {}),
-        ...(str(payload.reason) ? { reason: str(payload.reason) } : {}),
-        ...(str(payload.feedback) ? { feedback: str(payload.feedback) } : {}),
-        ...(view(payload.display) ? { display: view(payload.display) } : {}),
-        ...(details ? { details } : {}),
-    };
-}
-function child(payload, type) {
-    const event = childKind(type);
-    if (!event)
-        return null;
-    const display = view(payload.display);
-    return {
-        type: "child",
-        event,
-        ...(str(payload.rootRunId) ? { rootRunId: str(payload.rootRunId) } : {}),
-        ...(str(payload.parentRunId) ? { parentRunId: str(payload.parentRunId) } : {}),
-        ...(str(payload.subId) ? { subId: str(payload.subId) } : {}),
-        ...(num(payload.depth) !== undefined ? { depth: num(payload.depth) } : {}),
-        ...(str(payload.agentWallet) ? { agentWallet: str(payload.agentWallet) } : {}),
-        ...(str(payload.userAddress) ? { userAddress: str(payload.userAddress) } : {}),
-        ...(str(payload.runKey) ? { runKey: str(payload.runKey) } : {}),
-        ...(strings(payload.runKeyChain) ? { runKeyChain: strings(payload.runKeyChain) } : {}),
-        ...(typeof payload.delta === "string" ? { delta: payload.delta } : {}),
-        ...(str(payload.toolName) ? { toolName: str(payload.toolName) } : {}),
-        ...("input" in payload ? { input: payload.input } : {}),
-        ...("output" in payload ? { output: payload.output } : {}),
-        ...(typeof payload.failed === "boolean" ? { failed: payload.failed } : {}),
-        ...(str(payload.error) ? { error: str(payload.error) } : {}),
-        ...(obj(payload.usage) ? { usage: obj(payload.usage) } : {}),
-        ...(num(payload.toolBatches) !== undefined ? { toolBatches: num(payload.toolBatches) } : {}),
-        ...(str(payload.stopReason) ? { stopReason: str(payload.stopReason) } : {}),
-        ...(num(payload.wallMs) !== undefined ? { wallMs: num(payload.wallMs) } : {}),
-        ...(display ? { display } : {}),
-        ...(num(payload.ts) !== undefined ? { ts: num(payload.ts) } : {}),
-    };
-}
-function trace(payload, type) {
-    if (type !== "trace")
-        return null;
-    const source = str(payload.source);
-    if (!source || !["capability", "model", "tool", "agent", "harness", "swarm", "route"].includes(source))
-        return null;
-    const details = obj(payload.details);
-    return {
-        type: "trace",
-        source: source,
-        ...(str(payload.stage) ? { stage: str(payload.stage) } : {}),
-        ...(str(payload.action) ? { action: str(payload.action) } : {}),
-        ...(str(payload.message) ? { message: str(payload.message) } : {}),
-        ...(view(payload.display) ? { display: view(payload.display) } : {}),
-        ...(num(payload.ts) !== undefined ? { ts: num(payload.ts) } : {}),
-        ...(details ? { details } : {}),
-    };
 }
-function conclave(payload, type) {
-    if (type !== "conclave")
-        return null;
-    const action = str(payload.action);
-    if (!action || !["write", "read", "list", "delete"].includes(action))
-        return null;
-    return {
-        type: "conclave",
-        action: action,
-        success: payload.success === true,
-        ...(str(payload.key) ? { key: str(payload.key) } : {}),
-        ...(view(payload.display) ? { display: view(payload.display) } : {}),
-        ...(obj(payload.details) ? { details: obj(payload.details) } : {}),
-    };
+function handleToolEvent(event, events, wallet, requestId, ctx, rawType) {
+    const isStart = rawType === "tool_start" || rawType === "tool-start" || event.status === "running";
+    const toolName = event.name ?? "tool";
+    const target = event.target;
+    const display = target ? {
+        kind: target.kind,
+        ...(target.id ? { id: target.id } : {}),
+        ...(target.name ? { name: target.name } : {}),
+        ...(target.target ? { target: target.target } : {}),
+        ...(target.summary ? { summary: target.summary } : {}),
+        ...(target.details ? { details: target.details } : {}),
+    } : undefined;
+    const summary = target?.summary ?? rawString(event.raw, "message") ?? rawString(event.raw, "content");
+    const failed = event.status === "failed";
+    const error = rawString(event.raw, "error");
+    if (isStart) {
+        events.emit("toolCallStart", {
+            userAddress: wallet.address,
+            chainId: wallet.chainId,
+            requestId,
+            source: "agent",
+            toolCallId: toolName,
+            toolName,
+            ...(display?.name ? { displayName: display.name } : {}),
+            ...(display ? { display, targetKind: display.kind } : {}),
+            ...(display?.target ? { target: display.target } : {}),
+            summary,
+        });
+    }
+    else {
+        ctx.toolCalls.push({
+            toolName,
+            ...(display?.name ? { displayName: display.name } : {}),
+            ...(display ? { display, targetKind: display.kind } : {}),
+            ...(display?.target ? { target: display.target } : {}),
+            summary,
+            failed,
+            ...(error ? { error } : {}),
+        });
+        events.emit("toolCallEnd", {
+            userAddress: wallet.address,
+            chainId: wallet.chainId,
+            requestId,
+            source: "agent",
+            toolCallId: toolName,
+            toolName,
+            ...(display?.name ? { displayName: display.name } : {}),
+            ...(display ? { display, targetKind: display.kind } : {}),
+            ...(display?.target ? { target: display.target } : {}),
+            summary,
+            failed,
+            ...(error ? { error } : {}),
+        });
+    }
 }
-function emitChild(events, wallet, requestId, event) {
-    if (event.event === "delta")
+function handleChildEvent(event, events, wallet, requestId, rawType) {
+    const childEvent = mapChildEventType(rawType);
+    if (!childEvent)
         return;
+    const target = event.target;
+    const display = target ? {
+        kind: target.kind,
+        ...(target.id ? { id: target.id } : {}),
+        ...(target.name ? { name: target.name } : {}),
+        ...(target.target ? { target: target.target } : {}),
+        ...(target.summary ? { summary: target.summary } : {}),
+        ...(target.details ? { details: target.details } : {}),
+    } : undefined;
+    const details = target?.details;
+    const raw = event.raw;
     const payload = {
         userAddress: wallet.address,
         chainId: wallet.chainId,
         requestId,
         source: "agent",
-        event: event.event,
-        ...(event.rootRunId ? { rootRunId: event.rootRunId } : {}),
-        ...(event.parentRunId ? { parentRunId: event.parentRunId } : {}),
-        ...(event.subId ? { subId: event.subId } : {}),
-        ...(event.depth !== undefined ? { depth: event.depth } : {}),
-        ...(event.agentWallet ? { agentWallet: event.agentWallet } : {}),
-        ...(event.runKey ? { runKey: event.runKey } : {}),
-        ...(event.runKeyChain ? { runKeyChain: event.runKeyChain } : {}),
-        ...(event.toolName ? { toolName: event.toolName } : {}),
-        ...("input" in event ? { input: event.input } : {}),
-        ...("output" in event ? { output: event.output } : {}),
-        ...(event.failed !== undefined ? { failed: event.failed } : {}),
-        ...(event.error ? { error: event.error } : {}),
-        ...(event.usage ? { usage: event.usage } : {}),
-        ...(event.toolBatches !== undefined ? { toolBatches: event.toolBatches } : {}),
-        ...(event.stopReason ? { stopReason: event.stopReason } : {}),
-        ...(event.wallMs !== undefined ? { wallMs: event.wallMs } : {}),
-        ...(event.display ? { display: event.display } : {}),
-        ...(event.ts !== undefined ? { ts: event.ts } : {}),
+        event: childEvent,
+        ...(rawString(raw, "rootRunId") ? { rootRunId: rawString(raw, "rootRunId") } : {}),
+        ...(rawString(raw, "parentRunId") ? { parentRunId: rawString(raw, "parentRunId") } : {}),
+        ...(rawString(raw, "subId") ? { subId: rawString(raw, "subId") } : {}),
+        ...(typeof details?.depth === "number" ? { depth: details.depth } : {}),
+        ...(rawString(raw, "agentWallet") ? { agentWallet: rawString(raw, "agentWallet") } : {}),
+        ...(rawString(raw, "runKey") ? { runKey: rawString(raw, "runKey") } : {}),
+        ...(Array.isArray(event.path) ? { runKeyChain: event.path } : {}),
+        ...(rawString(raw, "toolName") ? { toolName: rawString(raw, "toolName") } : {}),
+        ...(raw && "input" in raw ? { input: raw.input } : {}),
+        ...(raw && "output" in raw ? { output: raw.output } : {}),
+        ...(event.status === "failed" ? { failed: true } : {}),
+        ...(rawString(raw, "error") ? { error: rawString(raw, "error") } : {}),
+        ...(raw && typeof raw.usage === "object" && raw.usage ? { usage: raw.usage } : {}),
+        ...(typeof details?.toolBatches === "number" ? { toolBatches: details.toolBatches } : {}),
+        ...(rawString(raw, "stopReason") ? { stopReason: rawString(raw, "stopReason") } : {}),
+        ...(typeof details?.wallMs === "number" ? { wallMs: details.wallMs } : {}),
+        ...(display ? { display } : {}),
+        ...(typeof details?.ts === "number" ? { ts: details.ts } : {}),
     };
-    if (event.event === "start") {
-        events.emit("childAgentStart", payload);
-    }
-    else if (event.event === "tool-start") {
-        events.emit("childAgentToolStart", payload);
-    }
-    else if (event.event === "tool-end") {
-        events.emit("childAgentToolEnd", payload);
-    }
-    else if (event.event === "done") {
-        events.emit("childAgentDone", payload);
-    }
-    else if (event.event === "error") {
-        events.emit("childAgentError", payload);
+    switch (childEvent) {
+        case "start":
+            events.emit("childAgentStart", payload);
+            break;
+        case "tool-start":
+            events.emit("childAgentToolStart", payload);
+            break;
+        case "tool-end":
+            events.emit("childAgentToolEnd", payload);
+            break;
+        case "done":
+            events.emit("childAgentDone", payload);
+            break;
+        case "error":
+            events.emit("childAgentError", payload);
+            break;
     }
 }
-function emitProposal(events, wallet, requestId, event) {
+function handlePlanEvent(event, events, wallet, requestId, rawType) {
+    const p = event.payload ?? {};
+    const display = event.target ? {
+        kind: event.target.kind,
+        ...(event.target.id ? { id: event.target.id } : {}),
+        ...(event.target.name ? { name: event.target.name } : {}),
+        ...(event.target.target ? { target: event.target.target } : {}),
+        ...(event.target.summary ? { summary: event.target.summary } : {}),
+        ...(event.target.details ? { details: event.target.details } : {}),
+    } : undefined;
     const payload = {
-        ...event,
+        type: rawType,
+        proposalId: String(p.proposalId ?? event.id),
+        version: Number(p.version ?? 1),
+        ...(typeof p.approvalId === "string" ? { approvalId: p.approvalId } : {}),
+        state: String(p.state ?? event.status ?? "pending"),
+        ...(p.decision ? { decision: p.decision } : {}),
+        ...(typeof p.rootRunId === "string" ? { rootRunId: p.rootRunId } : {}),
+        ...(event.runId ? { runId: event.runId } : {}),
+        ...(typeof p.requestedBy === "string" ? { requestedBy: p.requestedBy } : {}),
+        ...(p.proposal !== undefined ? { proposal: p.proposal } : {}),
+        ...(typeof p.markdown === "string" ? { markdown: p.markdown } : {}),
+        ...(typeof p.updatedAt === "number" ? { updatedAt: p.updatedAt } : {}),
+        ...(typeof p.approver === "string" ? { approver: p.approver } : {}),
+        ...(typeof p.reason === "string" ? { reason: p.reason } : {}),
+        ...(typeof p.feedback === "string" ? { feedback: p.feedback } : {}),
+        ...(display ? { display } : {}),
+        ...(event.target?.details ? { details: event.target.details } : {}),
         userAddress: wallet.address,
         chainId: wallet.chainId,
         requestId,
         source: "agent",
     };
-    switch (event.type) {
+    switch (rawType) {
         case "plan.proposed":
             events.emit("planProposed", payload);
             break;
@@ -726,31 +425,25 @@ function emitProposal(events, wallet, requestId, event) {
             break;
     }
 }
-function body(value) {
-    const record = obj(value);
-    if (!record)
-        return str(value);
-    return str(record.content)
-        ?? str(obj(record.kwargs)?.content)
-        ?? str(obj(record.lc_kwargs)?.content);
+// =============================================================================
+// Utilities
+// =============================================================================
+function rawString(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const v = record[key];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
 }
-function json(value) {
-    const text = body(value);
-    if (!text)
-        return null;
-    try {
-        return obj(JSON.parse(text));
+function mapChildEventType(rawType) {
+    switch (rawType) {
+        case "swarm_child_start": return "start";
+        case "swarm_child_tool_start": return "tool-start";
+        case "swarm_child_tool_end": return "tool-end";
+        case "swarm_child_done": return "done";
+        case "swarm_child_error": return "error";
+        default: return null;
     }
-    catch {
-        return null;
-    }
-}
-function display(toolName, payload) {
-    if (toolName !== "models_call")
-        return undefined;
-    const parsed = json(payload.output) ?? json(payload.message);
-    const model = obj(parsed?.model);
-    return str(model?.name) ?? str(model?.id) ?? str(model?.modelId);
 }
 function mergeSignals(a, b) {
     if (!a)
@@ -769,19 +462,4 @@ function mergeSignals(a, b) {
         },
     };
 }
-async function readAgentStreamFrame(iterator, timeoutMs) {
-    const pending = iterator.next();
-    if (!timeoutMs) {
-        return pending;
-    }
-    let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ done: true, value: undefined }), timeoutMs);
-    });
-    pending.catch(() => undefined);
-    const result = await Promise.race([pending, timeout]);
-    if (timer)
-        clearTimeout(timer);
-    return result;
-}
 //# sourceMappingURL=agent.js.map