elasticdash-test 0.1.17 → 0.1.18-alpha

package/src/interceptors/http.ts

@@ -1,4 +1,7 @@
 import { getCaptureContext } from '../capture/recorder.js'
+import { getCurrentTrace } from '../trace-adapter/context.js'
+import { getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
+import { rawDateNow } from './side-effects.js'
 
 // AI provider URLs are already captured by ai-interceptor.ts as "llm" steps.
 // Skip them here to avoid duplicate observations.
@@ -203,13 +206,95 @@ function reconstructStream(raw: string): ReadableStream<Uint8Array> {
 
 let originalFetch: typeof globalThis.fetch | undefined
 
+/** Synthesize a Response from a frozen HTTP event */
+function synthesizeFrozenResponse(frozen: import('../capture/event.js').WorkflowEvent): Response {
+  const frozenInput = frozen.input as Record<string, unknown> | undefined
+  const responseMeta = (frozenInput?.__elasticdashResponse ?? {}) as Record<string, unknown>
+  const status = typeof responseMeta.status === 'number' ? responseMeta.status : 200
+  const statusText = typeof responseMeta.statusText === 'string' ? responseMeta.statusText : ''
+  const headers = pickReplayResponseHeaders(
+    responseMeta.headers && typeof responseMeta.headers === 'object'
+      ? (responseMeta.headers as Record<string, unknown>)
+      : undefined,
+  )
+
+  if (frozen.streamed === true) {
+    const raw = typeof frozen.streamRaw === 'string' ? frozen.streamRaw : ''
+    return new Response(reconstructStream(raw), { status, statusText, headers })
+  }
+
+  const body = frozen.output != null ? JSON.stringify(frozen.output) : null
+  return new Response(body, { status, statusText, headers })
+}
+
+/** Execute a live fetch and record the event, returning both the Response and the recorded event */
+async function executeLiveAndRecord(
+  originalFetchFn: typeof globalThis.fetch,
+  input: string | URL | Request,
+  init: RequestInit | undefined,
+  id: number,
+  url: string,
+  method: string,
+  rawHeaders: RequestInit['headers'] | undefined,
+  rawBody: RequestInit['body'] | null | undefined,
+): Promise<{ response: Response; event: import('../capture/event.js').WorkflowEvent }> {
+  const query = parseQuery(url)
+  const body = parseBody(rawBody as RequestInit['body'] | null | undefined)
+  const headers = normalizeHeaders(rawHeaders)
+
+  const start = rawDateNow()
+  const res = await originalFetchFn(input, init)
+
+  const responseHeadersObj: Record<string, string> = {}
+  res.headers.forEach((v, k) => { responseHeadersObj[k] = v })
+
+  const elasticdashResponse = { status: res.status, statusText: res.statusText, headers: responseHeadersObj, url: res.url }
+  const baseInput = {
+    url, method,
+    ...(query ? { query } : {}),
+    ...(body !== undefined ? { body } : {}),
+    ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
+    __elasticdashResponse: elasticdashResponse,
+  }
+
+  if (isStreamingContentType(res.headers) && res.body) {
+    const [streamForCaller, streamForRecorder] = res.body.tee()
+    const vercelAI = isVercelAIDataStream(res.headers)
+    // Return immediately with a pending event; caller handles async recording
+    const eventPromise = bufferStream(streamForRecorder).then((rawText): import('../capture/event.js').WorkflowEvent => ({
+      id, type: 'http', name: 'fetch', input: baseInput,
+      output: vercelAI ? parseVercelAIDataStream(rawText) : null,
+      streamed: true, streamRaw: rawText, timestamp: start, durationMs: rawDateNow() - start,
+    })).catch((): import('../capture/event.js').WorkflowEvent => ({
+      id, type: 'http', name: 'fetch', input: baseInput,
+      output: null, streamed: true, streamRaw: '', timestamp: start, durationMs: rawDateNow() - start,
+    }))
+    const streamResponse = new Response(streamForCaller, { status: res.status, statusText: res.statusText, headers: res.headers })
+    // Attach promise as a property for async recording
+    ;(streamResponse as unknown as Record<string, unknown>).__eventPromise = eventPromise
+    return { response: streamResponse, event: null as unknown as import('../capture/event.js').WorkflowEvent }
+  }
+
+  let output: unknown = null
+  try { output = await res.clone().json() } catch { /* not JSON */ }
+
+  const event: import('../capture/event.js').WorkflowEvent = {
+    id, type: 'http', name: 'fetch', input: baseInput, output, timestamp: start, durationMs: rawDateNow() - start,
+  }
+  return { response: res, event }
+}
+
 export function interceptFetch(): void {
   if (originalFetch) return // already installed
   originalFetch = globalThis.fetch
 
   globalThis.fetch = async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    await tryAutoInitHttpContext()
     const ctx = getCaptureContext()
-    if (!ctx) return originalFetch!(input, init)
+    const httpCtx = getHttpRunContext()
+    const obsCtx = getObservabilityContext()
+
+    if (!ctx && !httpCtx && !obsCtx) return originalFetch!(input, init)
 
     const url =
       typeof input === 'string'
@@ -226,7 +311,44 @@ export function interceptFetch(): void {
       return originalFetch!(input, init)
     }
 
-    const { recorder, replay } = ctx
+    // --- Observability-only mode: record and push, no mocks/replay ---
+    if (!ctx && !httpCtx && obsCtx) {
+      const id = obsCtx.nextId()
+      const { response, event } = await executeLiveAndRecord(originalFetch!, input, init, id, url, method, rawHeaders, rawBody as RequestInit['body'] | null | undefined)
+      const eventPromise = (response as unknown as Record<string, unknown>).__eventPromise as Promise<import('../capture/event.js').WorkflowEvent> | undefined
+      if (eventPromise) {
+        eventPromise.then((ev) => pushTelemetryEvent(ev)).catch(() => {})
+      } else if (event) {
+        pushTelemetryEvent(event)
+      }
+      return response
+    }
+
+    // --- HTTP mode (no capture context) — replay frozen events or execute live ---
+    if (!ctx && httpCtx) {
+      const id = httpCtx.nextId()
+
+      // Replay frozen step
+      const frozen = getHttpFrozenEvent(id)
+      if (frozen && frozen.type === 'http') {
+        pushTelemetryEvent(frozen)
+        return synthesizeFrozenResponse(frozen)
+      }
+
+      // Not frozen → execute live, push telemetry
+      const { response, event } = await executeLiveAndRecord(originalFetch!, input, init, id, url, method, rawHeaders, rawBody as RequestInit['body'] | null | undefined)
+      const eventPromise = (response as unknown as Record<string, unknown>).__eventPromise as Promise<import('../capture/event.js').WorkflowEvent> | undefined
+      if (eventPromise) {
+        eventPromise.then((ev) => pushTelemetryEvent(ev)).catch(() => {})
+      } else if (event) {
+        pushTelemetryEvent(event)
+      }
+      return response
+    }
+
+    // --- Capture mode (existing behaviour, enhanced with telemetry + TraceHandle) ---
+    const trace = getCurrentTrace()
+    const { recorder, replay } = ctx!
     const id = recorder.nextId()
 
     if (replay.shouldReplay(id)) {
@@ -242,120 +364,36 @@ export function interceptFetch(): void {
 
       if (isReplayMatch && historicalEvent) {
         recorder.record(historicalEvent)
-
-        const replayMeta = (historicalInput?.__elasticdashResponse ?? {}) as Record<string, unknown>
-        const replayStatus = typeof replayMeta.status === 'number' ? replayMeta.status : 200
-        const replayStatusText = typeof replayMeta.statusText === 'string' ? replayMeta.statusText : ''
-        const replayHeaders = pickReplayResponseHeaders(
-          replayMeta.headers && typeof replayMeta.headers === 'object'
-            ? (replayMeta.headers as Record<string, unknown>)
-            : undefined,
-        )
-
-        if (historicalEvent.streamed === true) {
-          const raw = typeof historicalEvent.streamRaw === 'string' ? historicalEvent.streamRaw : ''
-          return new Response(reconstructStream(raw), {
-            status: replayStatus,
-            statusText: replayStatusText,
-            headers: replayHeaders,
-          })
+        if (httpCtx) pushTelemetryEvent(historicalEvent)
+        if (trace && typeof trace.recordToolCall === 'function') {
+          trace.recordToolCall({ name: 'fetch', args: { url, method }, result: historicalEvent.output, workflowEventId: id })
         }
 
-        const historicalOutput = replay.getRecordedResult(id)
-        const body = historicalOutput != null ? JSON.stringify(historicalOutput) : null
-        return new Response(body, {
-          status: replayStatus,
-          statusText: replayStatusText,
-          headers: replayHeaders,
-        })
+        return synthesizeFrozenResponse(historicalEvent)
       }
     }
 
-    const query = parseQuery(url)
-    const body = parseBody(rawBody as RequestInit['body'] | null | undefined)
-    const headers = normalizeHeaders(rawHeaders)
-
-    const start = Date.now()
-    const res = await originalFetch!(input, init)
-
-    const responseHeadersObj: Record<string, string> = {}
-    res.headers.forEach((v, k) => {
-      responseHeadersObj[k] = v
-    })
-
-    const elasticdashResponse = {
-      status: res.status,
-      statusText: res.statusText,
-      headers: responseHeadersObj,
-      url: res.url,
-    }
-
-    const baseInput = {
-      url,
-      method,
-      ...(query ? { query } : {}),
-      ...(body !== undefined ? { body } : {}),
-      ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
-      __elasticdashResponse: elasticdashResponse,
-    }
-
-    if (isStreamingContentType(res.headers) && res.body) {
-      const [streamForCaller, streamForRecorder] = res.body.tee()
-      const vercelAI = isVercelAIDataStream(res.headers)
-
+    const { response, event } = await executeLiveAndRecord(originalFetch!, input, init, id, url, method, rawHeaders, rawBody as RequestInit['body'] | null | undefined)
+    const eventPromise = (response as unknown as Record<string, unknown>).__eventPromise as Promise<import('../capture/event.js').WorkflowEvent> | undefined
+    if (eventPromise) {
       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,
-          })
-        })
+        eventPromise.then((ev) => {
+          recorder.record(ev)
+          if (httpCtx) pushTelemetryEvent(ev)
+          if (trace && typeof trace.recordToolCall === 'function') {
+            trace.recordToolCall({ name: 'fetch', args: { url, method }, result: ev.output, workflowEventId: id })
+          }
+        }).catch(() => {})
       )
-
-      return new Response(streamForCaller, {
-        status: res.status,
-        statusText: res.statusText,
-        headers: res.headers,
-      })
-    }
-
-    let output: unknown = null
-    try {
-      output = await res.clone().json()
-    } catch {
-      // not JSON — record null
+    } else if (event) {
+      recorder.record(event)
+      if (httpCtx) pushTelemetryEvent(event)
+      if (trace && typeof trace.recordToolCall === 'function') {
+        trace.recordToolCall({ name: 'fetch', args: { url, method }, result: event.output, workflowEventId: id })
+      }
     }
 
-    recorder.record({
-      id,
-      type: 'http',
-      name: 'fetch',
-      input: baseInput,
-      output,
-      timestamp: start,
-      durationMs: Date.now() - start,
-    })
-
-    return res
+    return response
   }
 }
 

package/src/interceptors/telemetry-push.ts

@@ -3,6 +3,8 @@ import { randomUUID } from 'node:crypto'
 import type { WorkflowEvent } from '../capture/event.js'
 import { extractSystemPrompt, replaceSystemPrompt, extractUserPrompts, replaceUserPrompt, lookupMockEntry, normaliseMockResult } from '../internals/mock-resolver.js'
 import type { AIMockEntry, UserPromptMockEntry } from '../internals/mock-resolver.js'
+import { debugLog } from '../utils/debug.js'
+import type { TelemetryBatcher } from '../telemetry-batcher.js'
 
 interface ToolMockEntry {
   mode: 'live' | 'mock-all' | 'mock-specific'
@@ -33,14 +35,48 @@ export interface HttpRunContext {
   userPromptCallCounters: Record<string, number>
 }
 
+export interface ObservabilityContext {
+  sessionId: string
+  serviceId: string
+  serverUrl: string
+  apiKey?: string
+  batcher: TelemetryBatcher
+  nextId: () => number
+  sampleRate: number
+  redactKeys: string[]
+  traceId: string
+}
+
 const g = globalThis as Record<string, unknown>
 const HTTP_RUN_ALS_KEY = '__elasticdash_http_run_als__'
 const GLOBAL_CTX_KEY = '__elasticdash_global_http_ctx__'
+const OBS_ALS_KEY = '__elasticdash_obs_als__'
+const GLOBAL_OBS_KEY = '__elasticdash_global_obs_ctx__'
+
 const httpRunAls: AsyncLocalStorage<HttpRunContext | undefined> =
   (g[HTTP_RUN_ALS_KEY] as AsyncLocalStorage<HttpRunContext | undefined>) ??
   new AsyncLocalStorage<HttpRunContext | undefined>()
 if (!g[HTTP_RUN_ALS_KEY]) g[HTTP_RUN_ALS_KEY] = httpRunAls
 
+const obsAls: AsyncLocalStorage<ObservabilityContext | undefined> =
+  (g[OBS_ALS_KEY] as AsyncLocalStorage<ObservabilityContext | undefined>) ??
+  new AsyncLocalStorage<ObservabilityContext | undefined>()
+if (!g[OBS_ALS_KEY]) g[OBS_ALS_KEY] = obsAls
+
+export function setObservabilityContext(ctx: ObservabilityContext): void {
+  obsAls.enterWith(ctx)
+  g[GLOBAL_OBS_KEY] = ctx
+}
+
+export function getObservabilityContext(): ObservabilityContext | undefined {
+  return obsAls.getStore() ?? (g[GLOBAL_OBS_KEY] as ObservabilityContext | undefined)
+}
+
+export function clearObservabilityContext(): void {
+  obsAls.enterWith(undefined)
+  g[GLOBAL_OBS_KEY] = undefined
+}
+
 function buildContext(
   runId: string,
   dashboardUrl: string,
@@ -83,6 +119,7 @@ export function setHttpRunContext(runId: string, dashboardUrl: string): void {
   const ctx = buildContext(runId, dashboardUrl, [], {})
   httpRunAls.enterWith(ctx)
   g[GLOBAL_CTX_KEY] = ctx
+  ensureInterceptorsInstalled().catch(() => {})
 }
 
 /**
@@ -119,6 +156,7 @@ export async function initHttpRunContext(runId: string, dashboardUrl: string): P
   const ctx = buildContext(runId, dashboardUrl, frozenEvents, promptMocks, toolMockConfig, aiMockConfig, userPromptMocks)
   httpRunAls.enterWith(ctx)
   g[GLOBAL_CTX_KEY] = ctx
+  await ensureInterceptorsInstalled()
 }
 
 export function getHttpRunContext(): HttpRunContext | undefined {
@@ -137,22 +175,22 @@ export function getHttpFrozenEvent(id: number): WorkflowEvent | undefined {
 export function getHttpPromptMock(input: unknown): unknown | undefined {
   const ctx = getHttpRunContext()
   if (!ctx || ctx.promptMocks.size === 0) {
-    console.log(`[elasticdash] getHttpPromptMock: skip — promptMocks.size=${ctx?.promptMocks.size ?? 'no ctx'}`)
+    debugLog(`[elasticdash] getHttpPromptMock: skip — promptMocks.size=${ctx?.promptMocks.size ?? 'no ctx'}`)
     return undefined
   }
   const systemPrompt = extractSystemPrompt(input)
   if (systemPrompt === undefined) {
     const inputKeys = (input && typeof input === 'object') ? Object.keys(input as object).join(',') : typeof input
-    console.log(`[elasticdash] getHttpPromptMock: no system prompt found in input (keys: ${inputKeys})`)
+    debugLog(`[elasticdash] getHttpPromptMock: no system prompt found in input (keys: ${inputKeys})`)
     return undefined
   }
   const newSystemPrompt = ctx.promptMocks.get(systemPrompt)
-  console.log(`[elasticdash] getHttpPromptMock: extracted system prompt (len=${systemPrompt.length}, first50=${JSON.stringify(systemPrompt.slice(0,50))}) — mock found=${newSystemPrompt !== undefined}`)
+  debugLog(`[elasticdash] getHttpPromptMock: extracted system prompt (len=${systemPrompt.length}, first50=${JSON.stringify(systemPrompt.slice(0,50))}) — mock found=${newSystemPrompt !== undefined}`)
   if (newSystemPrompt !== undefined) {
-    console.log(`[elasticdash] getHttpPromptMock: available mock keys=${JSON.stringify([...ctx.promptMocks.keys()].map(k => k.slice(0,50)))}`)
+    debugLog(`[elasticdash] getHttpPromptMock: available mock keys=${JSON.stringify([...ctx.promptMocks.keys()].map(k => k.slice(0,50)))}`)
   }
   if (newSystemPrompt === undefined) {
-    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)))}`)
+    debugLog(`[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 undefined
   }
   return replaceSystemPrompt(input, newSystemPrompt)
@@ -258,24 +296,59 @@ export function getHttpAIMock(modelName: string): MockResult {
 }
 
 export function pushTelemetryEvent(event: WorkflowEvent, explicitCtx?: { runId: string; dashboardUrl: string }): void {
+  // Observability mode: route to batcher with sampling
+  const obsCtx = getObservabilityContext()
+  if (obsCtx && !explicitCtx) {
+    if (obsCtx.sampleRate < 1 && Math.random() >= obsCtx.sampleRate) return
+    if (!event.traceId && obsCtx.traceId) {
+      event.traceId = obsCtx.traceId
+    }
+    obsCtx.batcher.enqueue(event)
+    return
+  }
+
   const ctx = explicitCtx ?? getHttpRunContext()
   if (!ctx) {
-    console.log(`[elasticdash] pushTelemetryEvent: no HTTP context, dropping event type=${event.type} name=${('name' in event ? event.name : '?')}`)
+    debugLog(`[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}`)
+  debugLog(`[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 : '?')}`)
+    debugLog(`[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)}`)
+    debugLog(`[elasticdash] pushTelemetryEvent: fetch failed: ${e instanceof Error ? e.message : String(e)}`)
   })
 }
 
+const INTERCEPTORS_KEY = '__elasticdash_interceptors_installed__'
+
+/**
+ * Ensures fetch (HTTP + AI) and DB interceptors are installed globally.
+ * Uses dynamic imports to avoid circular dependencies. Safe to call multiple
+ * times — only the first call does actual work.
+ */
+async function ensureInterceptorsInstalled(): Promise<void> {
+  if (g[INTERCEPTORS_KEY]) return
+  g[INTERCEPTORS_KEY] = true
+  try {
+    const [httpMod, aiMod, dbMod] = await Promise.all([
+      import('./http.js'),
+      import('./ai-interceptor.js'),
+      import('./db-auto.js'),
+    ])
+    httpMod.interceptFetch()
+    aiMod.installAIInterceptor()
+    await dbMod.installDBAutoInterceptor()
+  } catch {
+    // Non-fatal: interceptors may already be installed or deps missing
+  }
+}
+
 const AUTO_INIT_KEY = '__elasticdash_auto_init_promise__'
 
 /**
@@ -307,6 +380,7 @@ export async function runInHttpContext<T>(
   dashboardUrl: string,
   callback: () => Promise<T>,
 ): Promise<T> {
+  await ensureInterceptorsInstalled()
   const ctx = buildContext(runId, dashboardUrl, [], {})
   g[GLOBAL_CTX_KEY] = ctx
   try {
@@ -357,16 +431,17 @@ export async function runWithInitializedHttpContext<T>(
       }
       const mockKeys = Object.keys(promptMocks)
       const userMockKeys = Object.keys(userPromptMocks ?? {})
-      console.log(`[elasticdash] runWithInitializedHttpContext: fetched ${mockKeys.length} prompt mocks, ${userMockKeys.length} user prompt mocks, ${frozenEvents.length} frozen events`)
+      debugLog(`[elasticdash] runWithInitializedHttpContext: fetched ${mockKeys.length} prompt mocks, ${userMockKeys.length} user 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)))}`)
+        debugLog(`[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}`)
+      debugLog(`[elasticdash] runWithInitializedHttpContext: run-configs fetch returned ${res.status}`)
     }
   } catch {
     // Dashboard unreachable or run config not registered — proceed with live execution
   }
+  await ensureInterceptorsInstalled()
   const ctx = buildContext(runId, dashboardUrl, frozenEvents, promptMocks, toolMockConfig, aiMockConfig, userPromptMocks)
   g[GLOBAL_CTX_KEY] = ctx
   try {
@@ -379,12 +454,37 @@ export async function runWithInitializedHttpContext<T>(
 export async function tryAutoInitHttpContext(): Promise<void> {
   // Fast path: already initialised in this async context
   if (getHttpRunContext()) return
+  if (getObservabilityContext()) return
+
+  // Check for observability mode first (ELASTICDASH_API_URL)
+  const apiUrl = (typeof process !== 'undefined' && process.env?.ELASTICDASH_API_URL) ?? ''
+  if (apiUrl) {
+    const obsInitKey = '__elasticdash_obs_auto_init__'
+    if (!g[obsInitKey]) {
+      g[obsInitKey] = (async () => {
+        try {
+          // Dynamic import to avoid circular dependency at module load time
+          const { initObservability } = await import('../observability.js')
+          initObservability({
+            serverUrl: apiUrl,
+            apiKey: process.env.ELASTICDASH_API_KEY,
+            serviceId: process.env.ELASTICDASH_SERVICE_ID,
+            sessionId: process.env.ELASTICDASH_SESSION_ID,
+          })
+        } catch (err) {
+          debugLog(`[elasticdash] Observability auto-init failed: ${err instanceof Error ? err.message : String(err)}`)
+        }
+      })()
+    }
+    await (g[obsInitKey] as Promise<void>)
+    return
+  }
 
+  // Fall back to HTTP run context (ELASTICDASH_SERVER — dashboard/test mode)
   const serverUrl = (typeof process !== 'undefined' && process.env?.ELASTICDASH_SERVER) ?? ''
   if (!serverUrl) return
 
   // Deduplicate concurrent first calls within the same process
-  const g = globalThis as Record<string, unknown>
   if (!g[AUTO_INIT_KEY]) {
     g[AUTO_INIT_KEY] = (async () => {
       try {

package/src/interceptors/tool.ts

@@ -1,7 +1,8 @@
 import { getCaptureContext } from '../capture/recorder.js'
 import { getCurrentTrace } from '../trace-adapter/context.js'
 import { rawDateNow } from './side-effects.js'
-import { getHttpRunContext, getHttpFrozenEvent, getHttpToolMock, pushTelemetryEvent, tryAutoInitHttpContext } from './telemetry-push.js'
+import { getHttpRunContext, getHttpFrozenEvent, getHttpToolMock, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
+import { debugLog } from '../utils/debug.js'
 
 const TOOL_WRAPPER_ACTIVE_KEY = '__elasticdash_tool_wrapper_active__'
 
@@ -88,10 +89,46 @@ export function wrapTool<Args extends unknown[], R>(
     await tryAutoInitHttpContext()
     const ctx = getCaptureContext()
     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)
+    const obsCtx = getObservabilityContext()
+    debugLog(`[elasticdash] Tool called: ${name}`, { args })
+    debugLog(`[elasticdash] Current capture context:`, ctx ? { hasRecorder: !!ctx.recorder, hasReplay: !!ctx.replay } : null)
+    debugLog(`[elasticdash] Current HTTP context:`, httpCtx ? { hasHttpContext: !!httpCtx } : null)
+    if (!ctx && !httpCtx && !obsCtx) return fn(...args)
+
+    // Observability-only mode: record and push, no mocks/replay
+    if (!ctx && !httpCtx && obsCtx) {
+      const id = obsCtx.nextId()
+      const input = args.length === 1 ? args[0] : args
+      const start = rawDateNow()
+      try {
+        const output = await fn(...args)
+        const durationMs = rawDateNow() - start
+        if (isReadableStream(output)) {
+          const [streamForCaller, streamForRecorder] = output.tee()
+          bufferReadableStream(streamForRecorder).then((rawText) => {
+            const durationMs = rawDateNow() - start
+            pushTelemetryEvent({ id, type: 'tool', name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs })
+          }).catch(() => {
+            const durationMs = rawDateNow() - start
+            pushTelemetryEvent({ id, type: 'tool', name, input, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+          })
+          return streamForCaller as unknown as R
+        }
+        if (isAsyncIterable(output)) {
+          return wrapAsyncIterable(output, (chunks) => {
+            const durationMs = rawDateNow() - start
+            const rawText = chunks.map((c) => (typeof c === 'string' ? c : JSON.stringify(c))).join('')
+            pushTelemetryEvent({ id, type: 'tool', name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs })
+          }) as unknown as R
+        }
+        pushTelemetryEvent({ id, type: 'tool', name, input, output, timestamp: start, durationMs })
+        return output
+      } catch (e) {
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'tool', name, input, output: { error: String(e) }, timestamp: start, durationMs })
+        throw e
+      }
+    }
 
     // HTTP mode only (no capture context) — execute, record timing, push telemetry
     if (!ctx) {

package/src/interceptors/workflow-ai.ts

@@ -1,6 +1,6 @@
 import { getCaptureContext } from '../capture/recorder.js'
 import { rawDateNow } from './side-effects.js'
-import { getHttpRunContext, getHttpFrozenEvent, getHttpPromptMock, getHttpUserPromptMock, getHttpAIMock, pushTelemetryEvent, tryAutoInitHttpContext } from './telemetry-push.js'
+import { getHttpRunContext, getHttpFrozenEvent, getHttpPromptMock, getHttpUserPromptMock, getHttpAIMock, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
 import { resolveAIMock, resolvePromptMock, resolveUserPromptMock } from '../internals/mock-resolver.js'
 import type { WorkflowEvent } from '../capture/event.js'
 
@@ -115,11 +115,58 @@ export function wrapAI<Args extends unknown[], R>(
     await tryAutoInitHttpContext()
     const ctx = getCaptureContext()
     const httpCtx = getHttpRunContext()
+    const obsCtx = getObservabilityContext()
 
-    if (!ctx && !httpCtx) return callFn(...args)
+    if (!ctx && !httpCtx && !obsCtx) return callFn(...args)
 
     const start = rawDateNow()
 
+    // Observability-only mode: record and push, no mocks/replay
+    if (!ctx && !httpCtx && obsCtx) {
+      const id = obsCtx.nextId()
+      const input = args.length === 1 ? args[0] : args
+      try {
+        const output = await callFn(...args)
+
+        if (isReadableStream(output)) {
+          const [streamForCaller, streamForRecorder] = output.tee()
+          bufferReadableStream(streamForRecorder).then((rawText) => {
+            const durationMs = rawDateNow() - start
+            pushTelemetryEvent({ id, type: 'ai', name: modelName, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs })
+          }).catch(() => {
+            const durationMs = rawDateNow() - start
+            pushTelemetryEvent({ id, type: 'ai', name: modelName, input, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+          })
+          return streamForCaller as unknown as R
+        }
+
+        if (isAsyncIterable(output)) {
+          return wrapAsyncIterable(output, (chunks) => {
+            const durationMs = rawDateNow() - start
+            const rawText = chunks.map((c) => (typeof c === 'string' ? c : JSON.stringify(c))).join('')
+            pushTelemetryEvent({ id, type: 'ai', name: modelName, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs })
+          }) as unknown as R
+        }
+
+        const durationMs = rawDateNow() - start
+        const usage = extractUsage(output)
+        const event: WorkflowEvent = {
+          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
+      }
+    }
+
     if (ctx) {
       const { recorder, replay } = ctx
       const id = recorder.nextId()