elasticdash-test 0.1.13 → 0.1.16

package/dist/index.cjs

@@ -47,9 +47,21 @@ var init_recorder = __esm({
       events = [];
       _counter = 0;
       _sideEffectCounter = 0;
+      _pending = /* @__PURE__ */ new Set();
       record(event) {
         this.events.push(event);
       }
+      /** Register an in-flight async recording promise so flush() can await it. */
+      trackAsync(promise) {
+        this._pending.add(promise);
+        promise.finally(() => {
+          this._pending.delete(promise);
+        });
+      }
+      /** Await all in-flight async recordings. No-op when none are pending. */
+      async flush() {
+        await Promise.allSettled([...this._pending]);
+      }
       nextId() {
         return ++this._counter;
       }
@@ -173,7 +185,7 @@ function createTraceHandle() {
       steps.push({
         type: "llm",
         timestamp: rawDateNow(),
-        durationMs: 0,
+        durationMs: step.durationMs ?? 0,
         data: step
       });
     },
@@ -182,7 +194,7 @@ function createTraceHandle() {
       steps.push({
         type: "tool",
         timestamp: rawDateNow(),
-        durationMs: 0,
+        durationMs: call.durationMs ?? 0,
         data: call
       });
     },
@@ -227,7 +239,7 @@ __export(tracing_exports, {
 function wrapperRecordingActive() {
   return globalThis[TOOL_WRAPPER_ACTIVE_KEY] === true;
 }
-function recordToolCall(name, args, result) {
+function recordToolCall(name, args, result, durationMs = 0) {
   if (!globalThis.__ELASTICDASH_WORKER__) return;
   try {
     if (wrapperRecordingActive()) return;
@@ -235,7 +247,7 @@ function recordToolCall(name, args, result) {
     if (!trace || typeof trace.recordToolCall !== "function") return;
     const ctx = getCaptureContext();
     if (!ctx) {
-      trace.recordToolCall({ name, args, result });
+      trace.recordToolCall({ name, args, result, durationMs });
       return;
     }
     const { recorder, replay } = ctx;
@@ -255,9 +267,9 @@ function recordToolCall(name, args, result) {
       input: args,
       output,
       timestamp: rawDateNow(),
-      durationMs: 0
+      durationMs
     });
-    trace.recordToolCall({ name, args, result: output, workflowEventId: id });
+    trace.recordToolCall({ name, args, result: output, workflowEventId: id, durationMs });
   } catch {
   }
 }
@@ -290,28 +302,41 @@ __export(index_exports, {
   fetchCapturedTrace: () => fetchCapturedTrace,
   getCaptureContext: () => getCaptureContext,
   getCurrentTrace: () => getCurrentTrace,
+  getHttpFrozenEvent: () => getHttpFrozenEvent,
+  getHttpPromptMock: () => getHttpPromptMock,
+  getHttpRunContext: () => getHttpRunContext,
   getRegistry: () => getRegistry,
+  initHttpRunContext: () => initHttpRunContext,
   installAIInterceptor: () => installAIInterceptor,
   installDBAutoInterceptor: () => installDBAutoInterceptor,
   interceptDateNow: () => interceptDateNow,
   interceptFetch: () => interceptFetch,
   interceptRandom: () => interceptRandom,
   isWorker: () => isWorker,
+  pushTelemetryEvent: () => pushTelemetryEvent,
+  readVercelAIStream: () => readVercelAIStream,
   recordToolCall: () => recordToolCall,
   registerMatchers: () => registerMatchers,
   reportResults: () => reportResults,
+  resolveAIMock: () => resolveAIMock,
+  resolveMock: () => resolveMock,
+  resolvePromptMock: () => resolvePromptMock,
   resolveTaskInput: () => resolveTaskInput,
   restoreDateNow: () => restoreDateNow,
   restoreFetch: () => restoreFetch,
   restoreRandom: () => restoreRandom,
   runFiles: () => runFiles,
+  runInHttpContext: () => runInHttpContext,
+  runWithInitializedHttpContext: () => runWithInitializedHttpContext,
   runWorkflow: () => runWorkflow,
   safeRecordToolCall: () => safeRecordToolCall,
   serializeAgentState: () => serializeAgentState,
   setCaptureContext: () => setCaptureContext,
   setCurrentTrace: () => setCurrentTrace,
+  setHttpRunContext: () => setHttpRunContext,
   startLLMProxy: () => startLLMProxy,
   startTraceSession: () => startTraceSession,
+  tryAutoInitHttpContext: () => tryAutoInitHttpContext,
   uninstallAIInterceptor: () => uninstallAIInterceptor,
   uninstallDBAutoInterceptor: () => uninstallDBAutoInterceptor,
   wrapAI: () => wrapAI,
@@ -396,6 +421,7 @@ async function callProviderLLM(prompt, options = {}, systemPrompt = "You are an
   const provider = options.provider ?? "openai";
   const sdk = options.sdk;
   const resolvedModel = options.model ?? defaultModels[provider];
+  const t0 = Date.now();
   switch (provider) {
     case "openai": {
       if (sdk && sdk.chat?.completions?.create) {
@@ -408,7 +434,12 @@ async function callProviderLLM(prompt, options = {}, systemPrompt = "You are an
           max_tokens: maxTokens,
           temperature
         });
-        return resp?.choices?.[0]?.message?.content?.trim() ?? "";
+        const u2 = resp?.usage;
+        return {
+          content: resp?.choices?.[0]?.message?.content?.trim() ?? "",
+          durationMs: Date.now() - t0,
+          usage: u2 ? { inputTokens: u2.prompt_tokens ?? 0, outputTokens: u2.completion_tokens ?? 0, totalTokens: u2.total_tokens ?? 0 } : void 0
+        };
       }
       const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
       if (!apiKey) throw new Error("Provide apiKey or set OPENAI_API_KEY for OpenAI-compatible endpoint.");
@@ -433,7 +464,12 @@ async function callProviderLLM(prompt, options = {}, systemPrompt = "You are an
         throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data.choices?.[0]?.message?.content?.trim() ?? "";
+      const u = data?.usage;
+      return {
+        content: data.choices?.[0]?.message?.content?.trim() ?? "",
+        durationMs: Date.now() - t0,
+        usage: u ? { inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0, totalTokens: u.total_tokens ?? 0 } : void 0
+      };
     }
     case "claude": {
       if (sdk && sdk.messages?.create) {
@@ -445,7 +481,12 @@ async function callProviderLLM(prompt, options = {}, systemPrompt = "You are an
 
 ${prompt}` }]
         });
-        return resp?.content?.[0]?.text?.trim() ?? "";
+        const u2 = resp?.usage;
+        return {
+          content: resp?.content?.[0]?.text?.trim() ?? "",
+          durationMs: Date.now() - t0,
+          usage: u2 ? { inputTokens: u2.input_tokens ?? 0, outputTokens: u2.output_tokens ?? 0, totalTokens: (u2.input_tokens ?? 0) + (u2.output_tokens ?? 0) } : void 0
+        };
       }
       const apiKey = process.env.ANTHROPIC_API_KEY;
       if (!apiKey) throw new Error("ANTHROPIC_API_KEY is not set in environment.");
@@ -469,7 +510,12 @@ ${prompt}` }]
         throw new Error(`Claude API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data?.content?.[0]?.text?.trim() ?? "";
+      const u = data?.usage;
+      return {
+        content: data?.content?.[0]?.text?.trim() ?? "",
+        durationMs: Date.now() - t0,
+        usage: u ? { inputTokens: u.input_tokens ?? 0, outputTokens: u.output_tokens ?? 0, totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0) } : void 0
+      };
     }
     case "gemini": {
       if (sdk && sdk.models?.generateContent) {
@@ -480,7 +526,12 @@ ${prompt}` }]
 ${prompt}` }] }],
           generationConfig: { temperature, maxOutputTokens: maxTokens }
         });
-        return resp?.response?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+        const u2 = resp?.response?.usageMetadata;
+        return {
+          content: resp?.response?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "",
+          durationMs: Date.now() - t0,
+          usage: u2 ? { inputTokens: u2.promptTokenCount ?? 0, outputTokens: u2.candidatesTokenCount ?? 0, totalTokens: u2.totalTokenCount ?? 0 } : void 0
+        };
       }
       const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
       if (!apiKey) throw new Error("GEMINI_API_KEY (or GOOGLE_API_KEY) is not set in environment.");
@@ -501,7 +552,12 @@ ${prompt}` }] }],
         throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+      const u = data?.usageMetadata;
+      return {
+        content: data?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "",
+        durationMs: Date.now() - t0,
+        usage: u ? { inputTokens: u.promptTokenCount ?? 0, outputTokens: u.candidatesTokenCount ?? 0, totalTokens: u.totalTokenCount ?? 0 } : void 0
+      };
     }
     case "grok": {
       if (sdk && sdk.chat?.completions?.create) {
@@ -514,7 +570,12 @@ ${prompt}` }] }],
           max_tokens: maxTokens,
           temperature
         });
-        return resp?.choices?.[0]?.message?.content?.trim() ?? "";
+        const u2 = resp?.usage;
+        return {
+          content: resp?.choices?.[0]?.message?.content?.trim() ?? "",
+          durationMs: Date.now() - t0,
+          usage: u2 ? { inputTokens: u2.prompt_tokens ?? 0, outputTokens: u2.completion_tokens ?? 0, totalTokens: u2.total_tokens ?? 0 } : void 0
+        };
       }
       const apiKey = process.env.GROK_API_KEY;
       if (!apiKey) throw new Error("GROK_API_KEY is not set in environment.");
@@ -538,7 +599,12 @@ ${prompt}` }] }],
         throw new Error(`Grok API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data.choices?.[0]?.message?.content?.trim() ?? "";
+      const u = data?.usage;
+      return {
+        content: data.choices?.[0]?.message?.content?.trim() ?? "",
+        durationMs: Date.now() - t0,
+        usage: u ? { inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0, totalTokens: u.total_tokens ?? 0 } : void 0
+      };
     }
     case "kimi": {
       const apiKey = process.env.KIMI_API_KEY;
@@ -563,7 +629,12 @@ ${prompt}` }] }],
         throw new Error(`Kimi API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data.choices?.[0]?.message?.content?.trim() ?? "";
+      const u = data?.usage;
+      return {
+        content: data.choices?.[0]?.message?.content?.trim() ?? "",
+        durationMs: Date.now() - t0,
+        usage: u ? { inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0, totalTokens: u.total_tokens ?? 0 } : void 0
+      };
     }
     default:
       throw new Error(`Unsupported provider: ${provider}`);
@@ -581,7 +652,7 @@ ${expected}
 
 Answer only "YES" or "NO".
   `.trim();
-  const content = (await callProviderLLM(prompt, options, "You are an expert test judge.", 8, 0)).trim().toUpperCase();
+  const content = (await callProviderLLM(prompt, options, "You are an expert test judge.", 8, 0)).content.trim().toUpperCase();
   return content.startsWith("YES");
 }
 function parseFirstNumber(text) {
@@ -774,13 +845,13 @@ Text:
 ${targetText}
       `.trim();
       try {
-        const raw = await callProviderLLM(
+        const raw = (await callProviderLLM(
           evalPrompt,
           { provider: config.provider, model: config.model, sdk: config.sdk, apiKey: config.apiKey, baseURL: config.baseURL },
           "You are an evaluation assistant. Return only a number between 0 and 1.",
           16,
           0
-        );
+        )).content;
         const score = parseFirstNumber(raw);
         if (score === null) {
           return {
@@ -1391,9 +1462,51 @@ function formatError(error) {
 init_context();
 init_recorder();
 init_side_effects();
+function extractUsage(provider, body) {
+  if (provider === "openai" || provider === "grok" || provider === "kimi") {
+    const u = body.usage;
+    if (!u) return void 0;
+    return { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens };
+  }
+  if (provider === "anthropic") {
+    const u = body.usage;
+    if (!u) return void 0;
+    return { inputTokens: u.input_tokens, outputTokens: u.output_tokens, totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0) };
+  }
+  if (provider === "gemini") {
+    const u = body.usageMetadata;
+    if (!u) return void 0;
+    return { inputTokens: u.promptTokenCount, outputTokens: u.candidatesTokenCount, totalTokens: u.totalTokenCount };
+  }
+  return void 0;
+}
+function extractAssistantMessage(provider, body) {
+  if (provider === "openai" || provider === "grok" || provider === "kimi") {
+    const choices = body.choices;
+    if (Array.isArray(choices) && choices.length > 0) {
+      const msg = choices[0].message;
+      if (msg && typeof msg === "object") return msg;
+    }
+  }
+  if (provider === "anthropic") {
+    const content = body.content;
+    if (Array.isArray(content)) {
+      return { role: "assistant", content };
+    }
+  }
+  if (provider === "gemini") {
+    const candidates = body.candidates;
+    if (Array.isArray(candidates) && candidates.length > 0) {
+      const content = candidates[0].content;
+      if (content && typeof content === "object") return content;
+    }
+  }
+  return null;
+}
 var AI_PATTERNS2 = {
   openai: /https?:\/\/api\.openai\.com\/v1\/((chat\/)?completions|embeddings)/,
-  gemini: /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^/:]+:(generateContent|streamGenerateContent)/,
+  anthropic: /https?:\/\/api\.anthropic\.com\/v1\/messages/,
+  gemini: /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^\/:]+:(generateContent|streamGenerateContent)/,
   grok: /https?:\/\/api\.x\.ai\/v1\/(chat\/)?completions/,
   kimi: /https?:\/\/api\.moonshot\.ai\/v1\/(chat\/)?completions/
 };
@@ -1411,16 +1524,40 @@ function extractModel2(provider, body, url) {
   return typeof body.model === "string" ? body.model : "unknown";
 }
 function extractPrompt2(provider, body) {
-  if (provider === "openai" || provider === "grok" || provider === "kimi") {
+  if (provider === "openai" || provider === "anthropic" || provider === "grok" || provider === "kimi") {
+    let systemPrefix = "";
+    if (provider === "anthropic") {
+      if (typeof body.system === "string") {
+        systemPrefix = `system: ${body.system}
+`;
+      } else if (Array.isArray(body.system)) {
+        systemPrefix = body.system.map((b) => {
+          if (b && typeof b === "object") {
+            return String(b.text ?? "");
+          }
+          return String(b);
+        }).filter(Boolean).map((t) => `system: ${t}`).join("\n") + "\n";
+      }
+    }
     const messages = body.messages;
     if (Array.isArray(messages)) {
-      return messages.map((m) => {
+      const msgText = messages.map((m) => {
         if (m && typeof m === "object") {
           const msg = m;
-          return `${msg.role}: ${msg.content}`;
+          let content = msg.content;
+          if (Array.isArray(content)) {
+            content = content.map((b) => {
+              if (b && typeof b === "object") {
+                return String(b.text ?? "");
+              }
+              return String(b);
+            }).filter(Boolean).join("");
+          }
+          return `${msg.role}: ${content}`;
         }
         return String(m);
       }).join("\n");
+      return systemPrefix + msgText;
     }
     if (typeof body.prompt === "string") return body.prompt;
     if (typeof body.input === "string") return body.input;
@@ -1469,6 +1606,18 @@ function extractCompletion2(provider, responseBody) {
       }
     }
   }
+  if (provider === "anthropic") {
+    const content = responseBody.content;
+    if (Array.isArray(content)) {
+      return content.map((block) => {
+        if (block && typeof block === "object") {
+          const b = block;
+          if (b.type === "text" && typeof b.text === "string") return b.text;
+        }
+        return "";
+      }).filter(Boolean).join("");
+    }
+  }
   if (provider === "gemini") {
     const candidates = responseBody.candidates;
     if (Array.isArray(candidates) && candidates.length > 0) {
@@ -1524,6 +1673,21 @@ async function bufferSSEStream(provider, stream) {
       } catch {
       }
     }
+  } else if (provider === "anthropic") {
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      try {
+        const obj = JSON.parse(data);
+        if (obj.type === "content_block_delta") {
+          const delta = obj.delta;
+          if (delta && delta.type === "text_delta" && typeof delta.text === "string") {
+            completion += delta.text;
+          }
+        }
+      } catch {
+      }
+    }
   } else {
     for (const line of lines) {
       if (!line.startsWith("data: ")) continue;
@@ -1550,6 +1714,16 @@ function synthesizeCompletionJSON(provider, completion) {
       candidates: [{ content: { parts: [{ text: completion }], role: "model" }, finishReason: "STOP" }]
     };
   }
+  if (provider === "anthropic") {
+    return {
+      id: "replay",
+      type: "message",
+      role: "assistant",
+      content: [{ type: "text", text: completion }],
+      stop_reason: "end_turn",
+      stop_sequence: null
+    };
+  }
   return {
     id: "replay",
     object: "chat.completion",
@@ -1564,6 +1738,37 @@ function synthesizeSSEStream(provider, completion) {
         const chunk = `[{"candidates":[{"content":{"parts":[{"text":${JSON.stringify(completion)}}],"role":"model"},"finishReason":"STOP"}]}]
 `;
         ctrl.enqueue(encoder.encode(chunk));
+      } else if (provider === "anthropic") {
+        const msgStart = `event: message_start
+data: ${JSON.stringify({ type: "message_start", message: { id: "replay", type: "message", role: "assistant", content: [], stop_reason: null, stop_sequence: null } })}
+
+`;
+        const blockStart = `event: content_block_start
+data: ${JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })}
+
+`;
+        const delta = `event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: completion } })}
+
+`;
+        const blockStop = `event: content_block_stop
+data: ${JSON.stringify({ type: "content_block_stop", index: 0 })}
+
+`;
+        const msgDelta = `event: message_delta
+data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null } })}
+
+`;
+        const msgStop = `event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`;
+        ctrl.enqueue(encoder.encode(msgStart));
+        ctrl.enqueue(encoder.encode(blockStart));
+        ctrl.enqueue(encoder.encode(delta));
+        ctrl.enqueue(encoder.encode(blockStop));
+        ctrl.enqueue(encoder.encode(msgDelta));
+        ctrl.enqueue(encoder.encode(msgStop));
       } else {
         const frame1 = `data: ${JSON.stringify({ id: "replay", choices: [{ delta: { content: completion }, index: 0, finish_reason: null }] })}
 
@@ -1590,6 +1795,7 @@ function installAIInterceptor() {
     let model = "unknown";
     let prompt = "";
     let isStreaming = false;
+    let messages;
     try {
       const rawBody = init?.body;
       if (rawBody && typeof rawBody === "string") {
@@ -1597,6 +1803,8 @@ function installAIInterceptor() {
         model = extractModel2(provider, body, url);
         prompt = extractPrompt2(provider, body);
         isStreaming = body.stream === true;
+        if (Array.isArray(body.messages)) messages = body.messages;
+        else if (Array.isArray(body.contents)) messages = body.contents;
       }
     } catch {
     }
@@ -1639,33 +1847,38 @@ function installAIInterceptor() {
       if (isStreaming) {
         if (response2.body) {
           const [streamForCaller, streamForRecorder] = response2.body.tee();
-          bufferSSEStream(provider, streamForRecorder).then((completion) => {
-            const durationMs2 = rawDateNow() - start;
-            traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
-            recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: { streamed: true, completion }, timestamp: start, durationMs: durationMs2 });
-          }).catch(() => {
-            traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed-error)", workflowEventId: id });
-            recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs: rawDateNow() - start });
-          });
+          recorder.trackAsync(
+            bufferSSEStream(provider, streamForRecorder).then((completion) => {
+              const durationMs2 = rawDateNow() - start;
+              traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id, durationMs: durationMs2 });
+              recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt, messages }, output: { streamed: true, completion }, timestamp: start, durationMs: durationMs2 });
+            }).catch(() => {
+              const durationMs2 = rawDateNow() - start;
+              traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed-error)", workflowEventId: id, durationMs: durationMs2 });
+              recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt, messages }, output: null, timestamp: start, durationMs: durationMs2 });
+            })
+          );
           return new Response(streamForCaller, {
             status: response2.status,
             statusText: response2.statusText,
             headers: response2.headers
           });
         } else {
-          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed)", workflowEventId: id });
-          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs });
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed)", workflowEventId: id, durationMs });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt, messages }, output: null, timestamp: start, durationMs });
         }
       } else {
         try {
           const cloned = response2.clone();
           const responseBody = await cloned.json();
           const completion = extractCompletion2(provider, responseBody);
-          traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
-          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: responseBody, timestamp: start, durationMs });
+          const usage = extractUsage(provider, responseBody);
+          const assistantMessage = extractAssistantMessage(provider, responseBody);
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id, durationMs });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt, messages }, output: assistantMessage ?? responseBody, timestamp: start, durationMs, usage });
         } catch {
-          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "", workflowEventId: id });
-          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs });
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "", workflowEventId: id, durationMs });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt, messages }, output: null, timestamp: start, durationMs });
         }
       }
       return response2;
@@ -1736,6 +1949,136 @@ var isWorker = () => {
   return isWorkerContext();
 };
 
+// src/internals/mock-resolver.ts
+function normaliseMockResult(value) {
+  if (typeof value === "string") {
+    try {
+      return normaliseMockResult(JSON.parse(value));
+    } catch {
+      return value;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map(normaliseMockResult);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = normaliseMockResult(v);
+    }
+    return out;
+  }
+  return value;
+}
+function resolveMock(toolName) {
+  const g4 = globalThis;
+  const mocks = g4["__ELASTICDASH_TOOL_MOCKS__"];
+  if (!mocks) return { mocked: false };
+  const entry = mocks[toolName];
+  if (!entry || entry.mode === "live") return { mocked: false };
+  if (!g4["__ELASTICDASH_TOOL_CALL_COUNTERS__"]) {
+    g4["__ELASTICDASH_TOOL_CALL_COUNTERS__"] = {};
+  }
+  const counters = g4["__ELASTICDASH_TOOL_CALL_COUNTERS__"];
+  counters[toolName] = (counters[toolName] ?? 0) + 1;
+  const callNumber = counters[toolName];
+  if (entry.mode === "mock-all") {
+    const data = entry.mockData ?? {};
+    const raw = data[callNumber] !== void 0 ? data[callNumber] : data[0];
+    return { mocked: true, result: normaliseMockResult(raw) };
+  }
+  if (entry.mode === "mock-specific") {
+    const indices = entry.callIndices ?? [];
+    if (indices.includes(callNumber)) {
+      const data = entry.mockData ?? {};
+      return { mocked: true, result: normaliseMockResult(data[callNumber]) };
+    }
+    return { mocked: false };
+  }
+  return { mocked: false };
+}
+function extractSystemPrompt(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const o = input;
+  if (typeof o.system === "string") return o.system;
+  if (typeof o.systemPrompt === "string" && o.systemPrompt.length > 0) return o.systemPrompt;
+  const msgs = Array.isArray(o.messages) ? o.messages : Array.isArray(input) ? input : null;
+  if (msgs) {
+    for (const m of msgs) {
+      if (m && typeof m === "object") {
+        const msg = m;
+        if (msg.role === "system" && typeof msg.content === "string") return msg.content;
+      }
+    }
+  }
+  return void 0;
+}
+function replaceSystemPrompt(input, newSystemPrompt) {
+  if (!input || typeof input !== "object") return input;
+  const o = input;
+  if (typeof o.system === "string") return { ...o, system: newSystemPrompt };
+  if (typeof o.systemPrompt === "string") return { ...o, systemPrompt: newSystemPrompt };
+  if (Array.isArray(input)) {
+    return input.map((m) => {
+      if (m && typeof m === "object") {
+        const msg = m;
+        if (msg.role === "system" && typeof msg.content === "string") return { ...msg, content: newSystemPrompt };
+      }
+      return m;
+    });
+  }
+  if (Array.isArray(o.messages)) {
+    return {
+      ...o,
+      messages: o.messages.map((m) => {
+        if (m && typeof m === "object") {
+          const msg = m;
+          if (msg.role === "system" && typeof msg.content === "string") return { ...msg, content: newSystemPrompt };
+        }
+        return m;
+      })
+    };
+  }
+  return input;
+}
+function resolvePromptMock(input) {
+  const g4 = globalThis;
+  const mocks = g4["__ELASTICDASH_PROMPT_MOCKS__"];
+  if (!mocks || Object.keys(mocks).length === 0) return void 0;
+  const systemPrompt = extractSystemPrompt(input);
+  if (systemPrompt === void 0) return void 0;
+  const newSystemPrompt = mocks[systemPrompt];
+  if (newSystemPrompt === void 0) return void 0;
+  return replaceSystemPrompt(input, newSystemPrompt);
+}
+function resolveAIMock(modelName) {
+  const g4 = globalThis;
+  const mocks = g4["__ELASTICDASH_AI_MOCKS__"];
+  if (!mocks) return { mocked: false };
+  const entry = mocks[modelName];
+  if (!entry || entry.mode === "live") return { mocked: false };
+  if (!g4["__ELASTICDASH_AI_CALL_COUNTERS__"]) {
+    g4["__ELASTICDASH_AI_CALL_COUNTERS__"] = {};
+  }
+  const counters = g4["__ELASTICDASH_AI_CALL_COUNTERS__"];
+  counters[modelName] = (counters[modelName] ?? 0) + 1;
+  const callNumber = counters[modelName];
+  if (entry.mode === "mock-all") {
+    const data = entry.mockData ?? {};
+    const raw = data[callNumber] !== void 0 ? data[callNumber] : data[0];
+    return { mocked: true, result: normaliseMockResult(raw) };
+  }
+  if (entry.mode === "mock-specific") {
+    const indices = entry.callIndices ?? [];
+    if (indices.includes(callNumber)) {
+      const data = entry.mockData ?? {};
+      return { mocked: true, result: normaliseMockResult(data[callNumber]) };
+    }
+    return { mocked: false };
+  }
+  return { mocked: false };
+}
+
 // src/index.ts
 init_recorder();
 
@@ -1788,6 +2131,132 @@ var ReplayController = class {
 init_recorder();
 init_context();
 init_side_effects();
+
+// src/interceptors/telemetry-push.ts
+var import_node_async_hooks3 = require("node:async_hooks");
+var import_node_crypto3 = require("node:crypto");
+var g3 = globalThis;
+var HTTP_RUN_ALS_KEY = "__elasticdash_http_run_als__";
+var httpRunAls = g3[HTTP_RUN_ALS_KEY] ?? new import_node_async_hooks3.AsyncLocalStorage();
+if (!g3[HTTP_RUN_ALS_KEY]) g3[HTTP_RUN_ALS_KEY] = httpRunAls;
+function buildContext(runId, dashboardUrl, frozenEvents, promptMocksRecord = {}) {
+  let counter = 0;
+  const frozenMap = /* @__PURE__ */ new Map();
+  for (const e of frozenEvents) frozenMap.set(e.id, e);
+  const promptMocksMap = new Map(Object.entries(promptMocksRecord));
+  return { runId, dashboardUrl, nextId: () => ++counter, frozenEvents: frozenMap, promptMocks: promptMocksMap };
+}
+function setHttpRunContext(runId, dashboardUrl) {
+  httpRunAls.enterWith(buildContext(runId, dashboardUrl, [], {}));
+}
+async function initHttpRunContext(runId, dashboardUrl) {
+  let frozenEvents = [];
+  let promptMocks = {};
+  try {
+    const res = await fetch(`${dashboardUrl}/api/run-configs/${runId}`);
+    if (res.ok) {
+      const data = await res.json();
+      frozenEvents = Array.isArray(data.frozenEvents) ? data.frozenEvents : [];
+      promptMocks = data.promptMocks && typeof data.promptMocks === "object" && !Array.isArray(data.promptMocks) ? data.promptMocks : {};
+    }
+  } catch {
+  }
+  httpRunAls.enterWith(buildContext(runId, dashboardUrl, frozenEvents, promptMocks));
+}
+function getHttpRunContext() {
+  return httpRunAls.getStore();
+}
+function getHttpFrozenEvent(id) {
+  return httpRunAls.getStore()?.frozenEvents.get(id);
+}
+function getHttpPromptMock(input) {
+  const ctx = httpRunAls.getStore();
+  if (!ctx || ctx.promptMocks.size === 0) {
+    console.log(`[elasticdash] getHttpPromptMock: skip \u2014 promptMocks.size=${ctx?.promptMocks.size ?? "no ctx"}`);
+    return void 0;
+  }
+  const systemPrompt = extractSystemPrompt(input);
+  if (systemPrompt === void 0) {
+    const inputKeys = input && typeof input === "object" ? Object.keys(input).join(",") : typeof input;
+    console.log(`[elasticdash] getHttpPromptMock: no system prompt found in input (keys: ${inputKeys})`);
+    return void 0;
+  }
+  const newSystemPrompt = ctx.promptMocks.get(systemPrompt);
+  console.log(`[elasticdash] getHttpPromptMock: extracted system prompt (len=${systemPrompt.length}, first50=${JSON.stringify(systemPrompt.slice(0, 50))}) \u2014 mock found=${newSystemPrompt !== void 0}`);
+  if (newSystemPrompt !== void 0) {
+    console.log(`[elasticdash] getHttpPromptMock: available mock keys=${JSON.stringify([...ctx.promptMocks.keys()].map((k) => k.slice(0, 50)))}`);
+  }
+  if (newSystemPrompt === void 0) {
+    console.log(`[elasticdash] getHttpPromptMock: no mock for this prompt. Available mock keys (first 50 chars each): ${JSON.stringify([...ctx.promptMocks.keys()].map((k) => k.slice(0, 50)))}`);
+    return void 0;
+  }
+  return replaceSystemPrompt(input, newSystemPrompt);
+}
+function pushTelemetryEvent(event) {
+  const ctx = httpRunAls.getStore();
+  if (!ctx) {
+    console.log(`[elasticdash] pushTelemetryEvent: no HTTP context, dropping event type=${event.type} name=${"name" in event ? event.name : "?"}`);
+    return;
+  }
+  const { runId, dashboardUrl } = ctx;
+  console.log(`[elasticdash] pushTelemetryEvent: posting event type=${event.type} name=${"name" in event ? event.name : "?"} runId=${runId} to ${dashboardUrl}`);
+  fetch(`${dashboardUrl}/api/trace-events`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ runId, event })
+  }).then((r) => {
+    console.log(`[elasticdash] pushTelemetryEvent: response status=${r.status} for type=${event.type} name=${"name" in event ? event.name : "?"}`);
+  }).catch((e) => {
+    console.log(`[elasticdash] pushTelemetryEvent: fetch failed: ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
+var AUTO_INIT_KEY = "__elasticdash_auto_init_promise__";
+function runInHttpContext(runId, dashboardUrl, callback) {
+  return httpRunAls.run(buildContext(runId, dashboardUrl, [], {}), callback);
+}
+async function runWithInitializedHttpContext(runId, dashboardUrl, callback) {
+  let frozenEvents = [];
+  let promptMocks = {};
+  try {
+    const res = await fetch(`${dashboardUrl}/api/run-configs/${runId}`);
+    if (res.ok) {
+      const data = await res.json();
+      frozenEvents = Array.isArray(data.frozenEvents) ? data.frozenEvents : [];
+      promptMocks = data.promptMocks && typeof data.promptMocks === "object" && !Array.isArray(data.promptMocks) ? data.promptMocks : {};
+      const mockKeys = Object.keys(promptMocks);
+      console.log(`[elasticdash] runWithInitializedHttpContext: fetched ${mockKeys.length} prompt mocks, ${frozenEvents.length} frozen events`);
+      if (mockKeys.length > 0) {
+        console.log(`[elasticdash] runWithInitializedHttpContext: mock keys (first 80 chars each): ${JSON.stringify(mockKeys.map((k) => k.slice(0, 80)))}`);
+      }
+    } else {
+      console.log(`[elasticdash] runWithInitializedHttpContext: run-configs fetch returned ${res.status}`);
+    }
+  } catch {
+  }
+  return httpRunAls.run(buildContext(runId, dashboardUrl, frozenEvents, promptMocks), callback);
+}
+async function tryAutoInitHttpContext() {
+  if (getHttpRunContext()) return;
+  const serverUrl = (typeof process !== "undefined" && process.env?.ELASTICDASH_SERVER) ?? "";
+  if (!serverUrl) return;
+  const g4 = globalThis;
+  if (!g4[AUTO_INIT_KEY]) {
+    g4[AUTO_INIT_KEY] = (async () => {
+      try {
+        const runId = (typeof process !== "undefined" && process.env?.ELASTICDASH_RUN_ID) ?? "";
+        if (runId) {
+          await initHttpRunContext(runId, serverUrl);
+        } else {
+          setHttpRunContext((0, import_node_crypto3.randomUUID)(), serverUrl);
+        }
+      } catch {
+      }
+    })();
+  }
+  await g4[AUTO_INIT_KEY];
+}
+
+// src/interceptors/tool.ts
 var TOOL_WRAPPER_ACTIVE_KEY2 = "__elasticdash_tool_wrapper_active__";
 function toTraceArgs(input) {
   if (input && typeof input === "object" && !Array.isArray(input)) {
@@ -1851,8 +2320,55 @@ function wrapAsyncIterable(source, onComplete) {
 }
 function wrapTool(name, fn) {
   return async (...args) => {
+    await tryAutoInitHttpContext();
     const ctx = getCaptureContext();
-    if (!ctx) return fn(...args);
+    const httpCtx = getHttpRunContext();
+    console.log(`[elasticdash] Tool called: ${name}`, { args });
+    console.log(`[elasticdash] Current capture context:`, ctx ? { hasRecorder: !!ctx.recorder, hasReplay: !!ctx.replay } : null);
+    console.log(`[elasticdash] Current HTTP context:`, httpCtx ? { hasHttpContext: !!httpCtx } : null);
+    if (!ctx && !httpCtx) return fn(...args);
+    if (!ctx) {
+      const id2 = httpCtx.nextId();
+      const input2 = args.length === 1 ? args[0] : args;
+      const frozen = getHttpFrozenEvent(id2);
+      if (frozen) {
+        pushTelemetryEvent(frozen);
+        if (frozen.streamed === true) {
+          const raw = typeof frozen.streamRaw === "string" ? frozen.streamRaw : "";
+          return reconstructStream(raw);
+        }
+        return frozen.output;
+      }
+      const start2 = rawDateNow();
+      try {
+        const output = await fn(...args);
+        if (isReadableStream(output)) {
+          const [streamForCaller, streamForRecorder] = output.tee();
+          bufferReadableStream(streamForRecorder).then((rawText) => {
+            const durationMs2 = rawDateNow() - start2;
+            pushTelemetryEvent({ id: id2, type: "tool", name, input: input2, output: null, streamed: true, streamRaw: rawText, timestamp: start2, durationMs: durationMs2 });
+          }).catch(() => {
+            const durationMs2 = rawDateNow() - start2;
+            pushTelemetryEvent({ id: id2, type: "tool", name, input: input2, output: null, streamed: true, streamRaw: "", timestamp: start2, durationMs: durationMs2 });
+          });
+          return streamForCaller;
+        }
+        if (isAsyncIterable(output)) {
+          return wrapAsyncIterable(output, (chunks) => {
+            const durationMs2 = rawDateNow() - start2;
+            const rawText = chunks.map((c) => typeof c === "string" ? c : JSON.stringify(c)).join("");
+            pushTelemetryEvent({ id: id2, type: "tool", name, input: input2, output: null, streamed: true, streamRaw: rawText, timestamp: start2, durationMs: durationMs2 });
+          });
+        }
+        const durationMs = rawDateNow() - start2;
+        pushTelemetryEvent({ id: id2, type: "tool", name, input: input2, output, timestamp: start2, durationMs });
+        return output;
+      } catch (e) {
+        const durationMs = rawDateNow() - start2;
+        pushTelemetryEvent({ id: id2, type: "tool", name, input: input2, output: { error: String(e) }, timestamp: start2, durationMs });
+        throw e;
+      }
+    }
     const trace = getCurrentTrace();
     const { recorder, replay } = ctx;
     const id = recorder.nextId();
@@ -1874,18 +2390,24 @@ function wrapTool(name, fn) {
       }
       return replayed;
     }
-    const g3 = globalThis;
-    const prev = g3[TOOL_WRAPPER_ACTIVE_KEY2];
-    g3[TOOL_WRAPPER_ACTIVE_KEY2] = true;
+    const g4 = globalThis;
+    const prev = g4[TOOL_WRAPPER_ACTIVE_KEY2];
+    g4[TOOL_WRAPPER_ACTIVE_KEY2] = true;
     const start = rawDateNow();
     try {
       const output = await fn(...args);
       if (isReadableStream(output)) {
         const [streamForCaller, streamForRecorder] = output.tee();
         bufferReadableStream(streamForRecorder).then((rawText) => {
-          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: rawDateNow() - start });
+          const durationMs2 = rawDateNow() - start;
+          const event = { id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: durationMs2 };
+          recorder.record(event);
+          if (httpCtx) pushTelemetryEvent(event);
         }).catch(() => {
-          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: "", timestamp: start, durationMs: rawDateNow() - start });
+          const durationMs2 = rawDateNow() - start;
+          const event = { id, type: "tool", name, input, output: null, streamed: true, streamRaw: "", timestamp: start, durationMs: durationMs2 };
+          recorder.record(event);
+          if (httpCtx) pushTelemetryEvent(event);
         });
         const result = streamForCaller;
         if (trace && typeof trace.recordToolCall === "function") {
@@ -1895,71 +2417,179 @@ function wrapTool(name, fn) {
       }
       if (isAsyncIterable(output)) {
         const wrapped = wrapAsyncIterable(output, (chunks) => {
+          const durationMs2 = rawDateNow() - start;
           const rawText = chunks.map((c) => typeof c === "string" ? c : JSON.stringify(c)).join("");
-          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: rawDateNow() - start });
+          const event = { id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: durationMs2 };
+          recorder.record(event);
+          if (httpCtx) pushTelemetryEvent(event);
         });
         if (trace && typeof trace.recordToolCall === "function") {
           trace.recordToolCall({ name, args: toTraceArgs(input), result: wrapped, workflowEventId: id });
         }
         return wrapped;
       }
-      recorder.record({
-        id,
-        type: "tool",
-        name,
-        input,
-        output,
-        timestamp: start,
-        durationMs: rawDateNow() - start
-      });
+      const durationMs = rawDateNow() - start;
+      const successEvent = { id, type: "tool", name, input, output, timestamp: start, durationMs };
+      recorder.record(successEvent);
+      if (httpCtx) pushTelemetryEvent(successEvent);
       if (trace && typeof trace.recordToolCall === "function") {
-        trace.recordToolCall({ name, args: toTraceArgs(input), result: output, workflowEventId: id });
+        trace.recordToolCall({ name, args: toTraceArgs(input), result: output, workflowEventId: id, durationMs });
       }
       return output;
     } catch (e) {
-      recorder.record({
-        id,
-        type: "tool",
-        name,
-        input,
-        output: { error: String(e) },
-        timestamp: start,
-        durationMs: rawDateNow() - start
-      });
+      const durationMs = rawDateNow() - start;
+      const errorEvent = { id, type: "tool", name, input, output: { error: String(e) }, timestamp: start, durationMs };
+      recorder.record(errorEvent);
+      if (httpCtx) pushTelemetryEvent(errorEvent);
       if (trace && typeof trace.recordToolCall === "function") {
-        trace.recordToolCall({ name, args: toTraceArgs(input), result: { error: String(e) }, workflowEventId: id });
+        trace.recordToolCall({ name, args: toTraceArgs(input), result: { error: String(e) }, workflowEventId: id, durationMs });
       }
       throw e;
     } finally {
-      if (prev === void 0) delete g3[TOOL_WRAPPER_ACTIVE_KEY2];
-      else g3[TOOL_WRAPPER_ACTIVE_KEY2] = prev;
+      if (prev === void 0) delete g4[TOOL_WRAPPER_ACTIVE_KEY2];
+      else g4[TOOL_WRAPPER_ACTIVE_KEY2] = prev;
     }
   };
 }
 
 // src/interceptors/workflow-ai.ts
 init_recorder();
+init_side_effects();
+function extractUsage2(output) {
+  if (!output || typeof output !== "object") return void 0;
+  const o = output;
+  if (o.usage && typeof o.usage === "object") {
+    const u = o.usage;
+    if (u.input_tokens != null || u.output_tokens != null) {
+      return {
+        inputTokens: u.input_tokens,
+        outputTokens: u.output_tokens,
+        totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
+      };
+    }
+    if (u.prompt_tokens != null || u.completion_tokens != null) {
+      return {
+        inputTokens: u.prompt_tokens,
+        outputTokens: u.completion_tokens,
+        totalTokens: u.total_tokens
+      };
+    }
+  }
+  if (o.usageMetadata && typeof o.usageMetadata === "object") {
+    const u = o.usageMetadata;
+    return {
+      inputTokens: u.promptTokenCount,
+      outputTokens: u.candidatesTokenCount,
+      totalTokens: u.totalTokenCount
+    };
+  }
+  return void 0;
+}
 function wrapAI(modelName, callFn) {
   return async (...args) => {
+    await tryAutoInitHttpContext();
     const ctx = getCaptureContext();
-    if (!ctx) return callFn(...args);
-    const { recorder, replay } = ctx;
-    const id = recorder.nextId();
-    if (replay.shouldReplay(id)) {
-      return replay.getRecordedResult(id);
+    const httpCtx = getHttpRunContext();
+    if (!ctx && !httpCtx) return callFn(...args);
+    const start = rawDateNow();
+    if (ctx) {
+      const { recorder, replay } = ctx;
+      const id2 = recorder.nextId();
+      if (replay.shouldReplay(id2)) {
+        return replay.getRecordedResult(id2);
+      }
+      const aiMock = resolveAIMock(modelName);
+      if (aiMock.mocked) {
+        const input3 = args.length === 1 ? args[0] : args;
+        const event = {
+          id: id2,
+          type: "ai",
+          name: modelName,
+          input: input3,
+          output: aiMock.result,
+          timestamp: start,
+          durationMs: 0
+        };
+        recorder.record(event);
+        if (httpCtx) pushTelemetryEvent(event);
+        return aiMock.result;
+      }
+      const rawInput = args.length === 1 ? args[0] : args;
+      const modifiedInput = resolvePromptMock(rawInput);
+      const effectiveArgs = modifiedInput !== void 0 ? [modifiedInput] : args;
+      const input2 = modifiedInput !== void 0 ? modifiedInput : rawInput;
+      try {
+        const output = await callFn(...effectiveArgs);
+        const durationMs = rawDateNow() - start;
+        const usage = extractUsage2(output);
+        const event = {
+          id: id2,
+          type: "ai",
+          name: modelName,
+          input: input2,
+          output,
+          timestamp: start,
+          durationMs,
+          ...usage ? { usage } : {}
+        };
+        recorder.record(event);
+        if (httpCtx) pushTelemetryEvent(event);
+        return output;
+      } catch (e) {
+        const durationMs = rawDateNow() - start;
+        const event = {
+          id: id2,
+          type: "ai",
+          name: modelName,
+          input: input2,
+          output: { error: String(e) },
+          timestamp: start,
+          durationMs
+        };
+        recorder.record(event);
+        if (httpCtx) pushTelemetryEvent(event);
+        throw e;
+      }
+    }
+    const id = httpCtx.nextId();
+    const frozen = getHttpFrozenEvent(id);
+    if (frozen) {
+      pushTelemetryEvent(frozen);
+      return frozen.output;
+    }
+    const rawHttpInput = args.length === 1 ? args[0] : args;
+    const httpModifiedInput = getHttpPromptMock(rawHttpInput);
+    const httpEffectiveArgs = httpModifiedInput !== void 0 ? [httpModifiedInput] : args;
+    const input = httpModifiedInput !== void 0 ? httpModifiedInput : rawHttpInput;
+    try {
+      const output = await callFn(...httpEffectiveArgs);
+      const durationMs = rawDateNow() - start;
+      const usage = extractUsage2(output);
+      const event = {
+        id,
+        type: "ai",
+        name: modelName,
+        input,
+        output,
+        timestamp: start,
+        durationMs,
+        ...usage ? { usage } : {}
+      };
+      pushTelemetryEvent(event);
+      return output;
+    } catch (e) {
+      const durationMs = rawDateNow() - start;
+      pushTelemetryEvent({
+        id,
+        type: "ai",
+        name: modelName,
+        input,
+        output: { error: String(e) },
+        timestamp: start,
+        durationMs
+      });
+      throw e;
     }
-    const start = Date.now();
-    const output = await callFn(...args);
-    recorder.record({
-      id,
-      type: "ai",
-      name: modelName,
-      input: args.length === 1 ? args[0] : args,
-      output,
-      timestamp: start,
-      durationMs: Date.now() - start
-    });
-    return output;
   };
 }
 
@@ -2204,7 +2834,80 @@ function pickReplayResponseHeaders(headers) {
 }
 function isStreamingContentType(headers) {
   const ct = headers.get("content-type") ?? "";
-  return ct.includes("text/event-stream") || ct.includes("application/x-ndjson") || ct.includes("application/stream+json") || ct.includes("application/jsonl");
+  return ct.includes("text/event-stream") || ct.includes("application/x-ndjson") || ct.includes("application/stream+json") || ct.includes("application/jsonl") || headers.get("x-vercel-ai-data-stream") === "v1";
+}
+function isVercelAIDataStream(headers) {
+  return headers.get("x-vercel-ai-data-stream") === "v1";
+}
+function parseVercelAIDataStream(raw) {
+  let accumulatedText = "";
+  let resultData = {};
+  let errorMessage = "";
+  let hasError = false;
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const prefix = line.slice(0, colonIdx);
+    const payload = line.slice(colonIdx + 1);
+    try {
+      if (prefix === "0") {
+        accumulatedText += JSON.parse(payload);
+      } else if (prefix === "2") {
+        const events = JSON.parse(payload);
+        for (const event of events) {
+          if (event.type === "result" || event.type === "plan") {
+            resultData = { ...resultData, ...event };
+          }
+        }
+      } else if (prefix === "3") {
+        hasError = true;
+        errorMessage = JSON.parse(payload);
+      }
+    } catch {
+    }
+  }
+  if (hasError) {
+    return { message: errorMessage, type: "error", error: errorMessage };
+  }
+  if (accumulatedText) {
+    return { message: accumulatedText, type: "text", refinedQuery: resultData.refinedQuery };
+  }
+  if (resultData.type === "plan") {
+    return {
+      message: resultData.message ?? "",
+      type: "plan",
+      sessionId: resultData.sessionId,
+      awaitingApproval: true,
+      executionPlan: resultData.executionPlan,
+      refinedQuery: resultData.refinedQuery
+    };
+  }
+  return {
+    message: resultData.message ?? "",
+    type: "result",
+    refinedQuery: resultData.refinedQuery,
+    error: resultData.error,
+    planRejected: resultData.planRejected
+  };
+}
+async function readVercelAIStream(response) {
+  if (!response.body) {
+    return { message: "No response body", type: "error", error: "No response body" };
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let raw = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      raw += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return parseVercelAIDataStream(raw);
 }
 async function bufferStream(stream) {
   const decoder = new TextDecoder();
@@ -2302,31 +3005,34 @@ function interceptFetch() {
     };
     if (isStreamingContentType(res.headers) && res.body) {
       const [streamForCaller, streamForRecorder] = res.body.tee();
-      bufferStream(streamForRecorder).then((rawText) => {
-        recorder.record({
-          id,
-          type: "http",
-          name: "fetch",
-          input: baseInput,
-          output: null,
-          streamed: true,
-          streamRaw: rawText,
-          timestamp: start,
-          durationMs: Date.now() - start
-        });
-      }).catch(() => {
-        recorder.record({
-          id,
-          type: "http",
-          name: "fetch",
-          input: baseInput,
-          output: null,
-          streamed: true,
-          streamRaw: "",
-          timestamp: start,
-          durationMs: Date.now() - start
-        });
-      });
+      const vercelAI = isVercelAIDataStream(res.headers);
+      recorder.trackAsync(
+        bufferStream(streamForRecorder).then((rawText) => {
+          recorder.record({
+            id,
+            type: "http",
+            name: "fetch",
+            input: baseInput,
+            output: vercelAI ? parseVercelAIDataStream(rawText) : null,
+            streamed: true,
+            streamRaw: rawText,
+            timestamp: start,
+            durationMs: Date.now() - start
+          });
+        }).catch(() => {
+          recorder.record({
+            id,
+            type: "http",
+            name: "fetch",
+            input: baseInput,
+            output: null,
+            streamed: true,
+            streamRaw: "",
+            timestamp: start,
+            durationMs: Date.now() - start
+          });
+        })
+      );
       return new Response(streamForCaller, {
         status: res.status,
         statusText: res.statusText,
@@ -2381,6 +3087,7 @@ async function runWorkflow(workflowFn, options = {}) {
   }
   try {
     const result = await workflowFn();
+    await recorder.flush();
     return { result, trace: recorder.toTrace() };
   } finally {
     if (interceptHttp) restoreFetch();
@@ -2492,28 +3199,41 @@ function resolveRef(ref, previousOutputs) {
   fetchCapturedTrace,
   getCaptureContext,
   getCurrentTrace,
+  getHttpFrozenEvent,
+  getHttpPromptMock,
+  getHttpRunContext,
   getRegistry,
+  initHttpRunContext,
   installAIInterceptor,
   installDBAutoInterceptor,
   interceptDateNow,
   interceptFetch,
   interceptRandom,
   isWorker,
+  pushTelemetryEvent,
+  readVercelAIStream,
   recordToolCall,
   registerMatchers,
   reportResults,
+  resolveAIMock,
+  resolveMock,
+  resolvePromptMock,
   resolveTaskInput,
   restoreDateNow,
   restoreFetch,
   restoreRandom,
   runFiles,
+  runInHttpContext,
+  runWithInitializedHttpContext,
   runWorkflow,
   safeRecordToolCall,
   serializeAgentState,
   setCaptureContext,
   setCurrentTrace,
+  setHttpRunContext,
   startLLMProxy,
   startTraceSession,
+  tryAutoInitHttpContext,
   uninstallAIInterceptor,
   uninstallDBAutoInterceptor,
   wrapAI,