elasticdash-sdk 0.2.0

package/src/interceptors/http.ts

@@ -0,0 +1,393 @@
+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.
+const AI_URL_PATTERNS = [
+  /https?:\/\/api\.openai\.com\/v1\/((chat\/)?completions|embeddings)/,
+  /https?:\/\/api\.anthropic\.com\/v1\/messages/,
+  /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^/:]+:(generateContent|streamGenerateContent)/,
+  /https?:\/\/api\.x\.ai\/v1\/(chat\/)?completions/,
+  /https?:\/\/api\.moonshot\.ai\/v1\/(chat\/)?completions/,
+]
+
+function isAIProviderUrl(url: string): boolean {
+  return AI_URL_PATTERNS.some(p => p.test(url))
+}
+
+
+function parseQuery(url: string): Record<string, string> | undefined {
+  try {
+    const { searchParams } = new URL(url)
+    if (searchParams.size === 0) return undefined
+    return Object.fromEntries(searchParams.entries())
+  } catch {
+    // Relative URL — extract manually
+    const qIdx = url.indexOf('?')
+    if (qIdx === -1) return undefined
+    try {
+      const params = new URLSearchParams(url.slice(qIdx + 1))
+      if (![...params].length) return undefined
+      return Object.fromEntries(params.entries())
+    } catch {
+      return undefined
+    }
+  }
+}
+
+function parseBody(body?: RequestInit['body'] | null): unknown {
+  if (body == null) return undefined
+  if (typeof body === 'string') {
+    try { return JSON.parse(body) } catch { return body }
+  }
+  if (body instanceof URLSearchParams) {
+    return Object.fromEntries(body.entries())
+  }
+  return '[binary]'
+}
+
+function normalizeHeaders(headers?: RequestInit['headers']): Record<string, string> | undefined {
+  if (!headers) return undefined
+  if (headers instanceof Headers) {
+    const obj: Record<string, string> = {}
+    headers.forEach((v, k) => { obj[k] = v })
+    return obj
+  }
+  if (Array.isArray(headers)) return Object.fromEntries(headers)
+  return headers as Record<string, string>
+}
+
+function pickReplayResponseHeaders(headers?: Record<string, unknown>): Record<string, string> {
+  if (!headers) return { 'Content-Type': 'application/json' }
+  const out: Record<string, string> = {}
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === 'string') out[key] = value
+  }
+  if (!out['Content-Type']) out['Content-Type'] = 'application/json'
+  return out
+}
+
+function isStreamingContentType(headers: Headers): boolean {
+  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') ||
+    headers.get('x-vercel-ai-data-stream') === 'v1'
+  )
+}
+
+function isVercelAIDataStream(headers: Headers): boolean {
+  return headers.get('x-vercel-ai-data-stream') === 'v1'
+}
+
+interface VercelAIStreamResult {
+  type: 'text' | 'result' | 'plan' | 'error'
+  message: string
+  refinedQuery?: string
+  sessionId?: string
+  awaitingApproval?: boolean
+  executionPlan?: unknown[]
+  error?: string
+  planRejected?: boolean
+}
+
+function parseVercelAIDataStream(raw: string): VercelAIStreamResult {
+  let accumulatedText = ''
+  let resultData: Record<string, unknown> = {}
+  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) as string
+      } else if (prefix === '2') {
+        const events = JSON.parse(payload) as Array<Record<string, unknown>>
+        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) as string
+      }
+    } catch {
+      // ignore malformed frames
+    }
+  }
+
+  if (hasError) {
+    return { message: errorMessage, type: 'error', error: errorMessage }
+  }
+  if (accumulatedText) {
+    return { message: accumulatedText, type: 'text', refinedQuery: resultData.refinedQuery as string | undefined }
+  }
+  if (resultData.type === 'plan') {
+    return {
+      message: (resultData.message as string) ?? '',
+      type: 'plan',
+      sessionId: resultData.sessionId as string | undefined,
+      awaitingApproval: true,
+      executionPlan: resultData.executionPlan as unknown[] | undefined,
+      refinedQuery: resultData.refinedQuery as string | undefined,
+    }
+  }
+  return {
+    message: (resultData.message as string) ?? '',
+    type: 'result',
+    refinedQuery: resultData.refinedQuery as string | undefined,
+    error: resultData.error as string | undefined,
+    planRejected: resultData.planRejected as boolean | undefined,
+  }
+}
+
+export type { VercelAIStreamResult }
+
+/**
+ * Reads a Vercel AI SDK data-stream response to completion and returns a
+ * structured result. Use this inside workflow functions that call the streaming
+ * endpoint via fetch so the framework can intercept and replay the call.
+ *
+ * @param response - The fetch Response whose body carries the
+ *                   `x-vercel-ai-data-stream: v1` wire protocol.
+ */
+export async function readVercelAIStream(response: Response): Promise<VercelAIStreamResult> {
+  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)
+}
+
+function reconstructStream(raw: string): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder()
+  return new ReadableStream<Uint8Array>({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(raw))
+      ctrl.close()
+    },
+  })
+}
+
+let originalFetch: typeof globalThis.fetch | undefined
+
+/**
+ * Returns the original unpatched fetch. SDK-internal calls (telemetry,
+ * catalog, triggers) must use this to avoid being recorded as trace events.
+ */
+export function getOriginalFetch(): typeof globalThis.fetch {
+  return originalFetch ?? globalThis.fetch
+}
+
+/** 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) {
+    // Streaming responses are not captured — the individual tool/AI calls
+    // inside the handler are already recorded separately. Pass through
+    // without buffering to avoid holding large streams in memory.
+    const event: import('../capture/event.js').WorkflowEvent = {
+      id, type: 'http', name: 'fetch', input: baseInput,
+      output: null, streamed: true, timestamp: start, durationMs: rawDateNow() - start,
+    }
+    return { response: res, event }
+  }
+
+  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()
+    const httpCtx = getHttpRunContext()
+    const obsCtx = getObservabilityContext()
+
+    if (!ctx && !httpCtx && !obsCtx) return originalFetch!(input, init)
+
+    const url =
+      typeof input === 'string'
+        ? input
+        : input instanceof URL
+          ? input.href
+          : (input as Request).url
+    const method = (init?.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase()
+    const rawHeaders = init?.headers ?? (input instanceof Request ? input.headers : undefined)
+    const rawBody = init?.body ?? (input instanceof Request ? input.body : undefined)
+
+    // Let ai-interceptor handle AI provider URLs — it assigns its own event IDs
+    if (isAIProviderUrl(url)) {
+      return originalFetch!(input, init)
+    }
+
+
+    // --- 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)) {
+      const historicalEvent = replay.getRecordedEvent(id)
+      const historicalInput = historicalEvent?.input as Record<string, unknown> | undefined
+      const historicalMethod = typeof historicalInput?.method === 'string' ? historicalInput.method.toUpperCase() : 'GET'
+      const historicalUrl = typeof historicalInput?.url === 'string' ? historicalInput.url : undefined
+      const isReplayMatch = !!historicalEvent
+        && historicalEvent.type === 'http'
+        && historicalEvent.name === 'fetch'
+        && historicalMethod === method
+        && historicalUrl === url
+
+      if (isReplayMatch && historicalEvent) {
+        recorder.record(historicalEvent)
+        if (httpCtx) pushTelemetryEvent(historicalEvent)
+        if (trace && typeof trace.recordToolCall === 'function') {
+          trace.recordToolCall({ name: 'fetch', args: { url, method }, result: historicalEvent.output, workflowEventId: id })
+        }
+
+        return synthesizeFrozenResponse(historicalEvent)
+      }
+    }
+
+    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(
+        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(() => {})
+      )
+    } 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 })
+      }
+    }
+
+    return response
+  }
+}
+
+export function restoreFetch(): void {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch
+    originalFetch = undefined
+  }
+}

package/src/interceptors/side-effects.ts

@@ -0,0 +1,83 @@
+import { getCaptureContext } from '../capture/recorder.js'
+
+let originalRandom: (() => number) | undefined
+let originalDateNow: (() => number) | undefined
+
+/** Call the real Date.now(), bypassing any interception. Safe to call from inside interceptors. */
+export function rawDateNow(): number {
+  return originalDateNow ? originalDateNow() : Date.now()
+}
+
+export function interceptRandom(): void {
+  if (originalRandom) return // already installed
+  originalRandom = Math.random
+
+  Math.random = (): number => {
+    const ctx = getCaptureContext()
+    if (!ctx) return originalRandom!()
+
+    const { recorder, replay } = ctx
+    const n = recorder.nextSideEffectId()
+
+    if (replay.shouldReplaySideEffectOfType(n, 'Math.random')) {
+      return replay.getSideEffectResultOfType(n, 'Math.random') as number
+    }
+
+    const value = originalRandom!()
+    recorder.record({
+      id: n,
+      type: 'side_effect',
+      name: 'Math.random',
+      input: null,
+      output: value,
+      timestamp: rawDateNow(),
+      durationMs: 0,
+    })
+
+    return value
+  }
+}
+
+export function restoreRandom(): void {
+  if (originalRandom) {
+    Math.random = originalRandom
+    originalRandom = undefined
+  }
+}
+
+export function interceptDateNow(): void {
+  if (originalDateNow) return // already installed
+  originalDateNow = Date.now
+
+  Date.now = (): number => {
+    const ctx = getCaptureContext()
+    if (!ctx) return originalDateNow!()
+
+    const { recorder, replay } = ctx
+    const n = recorder.nextSideEffectId()
+
+    if (replay.shouldReplaySideEffectOfType(n, 'Date.now')) {
+      return replay.getSideEffectResultOfType(n, 'Date.now') as number
+    }
+
+    const value = originalDateNow!()
+    recorder.record({
+      id: n,
+      type: 'side_effect',
+      name: 'Date.now',
+      input: null,
+      output: value,
+      timestamp: value,
+      durationMs: 0,
+    })
+
+    return value
+  }
+}
+
+export function restoreDateNow(): void {
+  if (originalDateNow) {
+    Date.now = originalDateNow
+    originalDateNow = undefined
+  }
+}