clawmoney 0.15.5 → 0.15.6

package/dist/relay/provider.js

@@ -161,7 +161,7 @@ function extractMessageText(content) {
 function messagesToPrompt(messages) {
     return messages.map((m) => extractMessageText(m.content)).join("\n");
 }
-async function executeRelayRequest(request, config) {
+async function executeRelayRequest(request, config, sendChunk) {
     const { request_id, max_budget_usd } = request;
     const cliType = request.cli_type ?? config.relay.cli_type;
     const model = request.model ?? config.relay.model;
@@ -217,6 +217,12 @@ async function executeRelayRequest(request, config) {
                 prompt,
                 model,
                 maxTokens: max_budget_usd ? undefined : 4096,
+                // Forward each raw Anthropic SSE frame to the Hub in real time
+                // so the end client sees tokens as they're generated (instead of
+                // waiting for the whole response to arrive). Only claude-api has
+                // true pass-through streaming today — codex/gemini/antigravity
+                // still buffer the full response upstream and emit a single frame.
+                onRawEvent: sendChunk,
             });
         }
         const elapsedMs = Date.now() - startMs;
@@ -330,7 +336,20 @@ export function runRelayProvider(cliOverride) {
         }
         activeTasks.add(request.request_id);
         logger.info(`Processing relay request=${request.request_id} (active=${activeTasks.size}/${config.relay.concurrency})`);
-        executeRelayRequest(request, config)
+        // Per-request SSE chunk forwarder. Each raw Anthropic SSE frame is sent
+        // to the Hub as its own WS event so the Hub can relay it straight to the
+        // buyer — drops TTFT from "whole response" to "first-token-from-upstream".
+        // WS sends are fire-and-forget here; the final relay_response still
+        // carries the fully aggregated content as a fallback for Hubs that
+        // haven't wired up chunk forwarding yet.
+        const sendChunk = (sse) => {
+            wsClient.send({
+                event: "relay_stream_chunk",
+                request_id: request.request_id,
+                sse,
+            });
+        };
+        executeRelayRequest(request, config, sendChunk)
             .then((response) => {
             const sent = wsClient.send(response);
             if (sent) {

package/dist/relay/types.d.ts

@@ -51,7 +51,12 @@ export interface RelayResponse {
     error?: string;
     session_window?: RelayResponseSessionWindow;
 }
-export type RelayOutgoingEvent = RelayResponse;
+export interface RelayStreamChunkEvent {
+    event: "relay_stream_chunk";
+    request_id: string;
+    sse: string;
+}
+export type RelayOutgoingEvent = RelayResponse | RelayStreamChunkEvent;
 export interface ParsedOutput {
     text: string;
     sessionId: string;

package/dist/relay/upstream/claude-api.d.ts

@@ -27,5 +27,6 @@ export interface CallClaudeApiOptions {
     prompt: string;
     model: string;
     maxTokens?: number;
+    onRawEvent?: (rawFrame: string) => void;
 }
 export declare function callClaudeApi(opts: CallClaudeApiOptions): Promise<ParsedOutput>;

package/dist/relay/upstream/claude-api.js

@@ -820,7 +820,10 @@ async function doCallClaudeApi(opts) {
             // Stream parser — real Claude Code's main path uses stream:true; see
             // body construction above. parseClaudeSseResponse aggregates text
             // deltas + usage until message_stop, matching SDK semantics.
-            const parsed = await parseClaudeSseResponse(resp, opts.model);
+            // When opts.onRawEvent is set, each SSE frame is also forwarded
+            // verbatim so the Hub can stream it through to the end client in
+            // real time instead of waiting for the whole response.
+            const parsed = await parseClaudeSseResponse(resp, opts.model, opts.onRawEvent);
             recordSpendFromUsage(parsed, opts.model);
             return parsed;
         }
@@ -911,7 +914,7 @@ function recordSpendFromUsage(parsed, model) {
  *   event: error           (upstream error — throw)
  *   data: {"type":"error","error":{"type":"overloaded_error","message":"..."}}
  */
-async function parseClaudeSseResponse(resp, fallbackModel) {
+async function parseClaudeSseResponse(resp, fallbackModel, onRawFrame) {
     const reader = resp.body?.getReader();
     if (!reader) {
         throw new Error("Claude streamGenerateContent returned no body");
@@ -925,6 +928,10 @@ async function parseClaudeSseResponse(resp, fallbackModel) {
     let cacheCreation = 0;
     let cacheRead = 0;
     let streamError;
+    // Accumulates one SSE frame (everything between blank lines) so we can
+    // emit the full `event: X\ndata: Y\n\n` block via onRawFrame. SSE frames
+    // are terminated by an empty line per the spec.
+    let frameLines = [];
     const processChunk = (jsonStr) => {
         const trimmed = jsonStr.trim();
         if (!trimmed)
@@ -992,6 +999,22 @@ async function parseClaudeSseResponse(resp, fallbackModel) {
                 break;
         }
     };
+    const flushFrame = () => {
+        if (frameLines.length === 0)
+            return;
+        // Forward the raw SSE frame verbatim so consumers see it exactly as
+        // Anthropic emitted it (including the event: name line, which Claude
+        // Code's SDK parser uses as the dispatch key).
+        if (onRawFrame) {
+            onRawFrame(frameLines.join("\n") + "\n\n");
+        }
+        for (const line of frameLines) {
+            if (line.startsWith("data:")) {
+                processChunk(line.slice(5));
+            }
+        }
+        frameLines = [];
+    };
     while (true) {
         const { value, done } = await reader.read();
         if (done)
@@ -1001,19 +1024,18 @@ async function parseClaudeSseResponse(resp, fallbackModel) {
         while ((newlineIdx = buffer.indexOf("\n")) >= 0) {
             const line = buffer.slice(0, newlineIdx).replace(/\r$/, "");
             buffer = buffer.slice(newlineIdx + 1);
-            if (!line)
-                continue;
-            // SSE dispatches on `data: ...` lines. `event: ...` names are
-            // informational (the chunk JSON's `type` field is authoritative).
-            if (line.startsWith("data:")) {
-                processChunk(line.slice(5));
+            if (line === "") {
+                // Blank line = end of SSE frame.
+                flushFrame();
+            }
+            else {
+                frameLines.push(line);
             }
         }
     }
-    // Flush trailing line (rare — most servers end with a \n\n).
-    if (buffer.startsWith("data:")) {
-        processChunk(buffer.slice(5));
-    }
+    // Flush any trailing frame without a final blank line. Rare, but SSE
+    // allows a stream to end without a terminating \n\n.
+    flushFrame();
     if (streamError) {
         throw new Error(`Anthropic stream error: ${streamError.type ?? "unknown"} — ${streamError.message ?? ""}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {