clawmoney 0.15.4 → 0.15.6

package/dist/relay/provider.js

@@ -134,10 +134,34 @@ function applyProxyFromConfig(config) {
     logger.info(`[provider] using config.yaml proxy=${config.proxy}`);
 }
 // ── Request handler ──
+// Flatten a Claude/OpenAI message `content` field into a plain string.
+// Content may be either a string (OpenAI-style) or an array of content
+// blocks (Claude Code / real Anthropic API shape: [{type:"text",text:"..."}]).
+// String(array) would produce "[object Object],[object Object]" which the
+// model then echoes back as garbage — hence the explicit block walk.
+function extractMessageText(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block && typeof block === "object") {
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string" && b.text) {
+                    parts.push(b.text);
+                }
+            }
+        }
+        return parts.join("\n");
+    }
+    return "";
+}
 function messagesToPrompt(messages) {
-    return messages.map((m) => String(m.content ?? "")).join("\n");
+    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;
@@ -148,7 +172,7 @@ async function executeRelayRequest(request, config) {
         ? messagesToPrompt(request.messages)
         : request.prompt ?? "";
     const lastUserMsg = request.messages
-        ? [...request.messages].reverse().find((m) => m.role === "user")?.content ?? ""
+        ? extractMessageText([...request.messages].reverse().find((m) => m.role === "user")?.content)
         : prompt;
     const turns = request.messages
         ? request.messages.filter((m) => m.role === "user").length
@@ -193,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;
@@ -306,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

@@ -1,10 +1,15 @@
+export interface RelayContentBlock {
+    type: string;
+    text?: string;
+}
+export type RelayMessageContent = string | RelayContentBlock[] | null;
 export interface RelayRequest {
     event: "relay_request";
     request_id: string;
     prompt?: string;
     messages?: Array<{
         role: string;
-        content: string;
+        content: RelayMessageContent;
     }>;
     cli_type?: string;
     session_id?: string;
@@ -46,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.4",
+  "version": "0.15.6",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {