elasticdash-test 0.1.17 → 0.1.18-alpha-2

package/src/execution/tool-runner.ts

@@ -0,0 +1,304 @@
+/**
+ * Shared tool/AI execution helpers for portal and dashboard.
+ * These are extracted versions of the helpers in dashboard-server.ts
+ * to avoid importing the full dashboard server module.
+ */
+import path from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { pathToFileURL } from 'node:url'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ToolInfo {
+  name: string
+  isAsync: boolean
+  signature: string
+  filePath: string
+  lineNumber?: number
+  sourceCode?: string
+}
+
+export interface RerunResult {
+  ok: boolean
+  currentOutput?: unknown
+  currentDurationMs?: number
+  currentUsage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number }
+  error?: string
+}
+
+interface ParsedExport {
+  name: string
+  isAsync: boolean
+  signature: string
+  filePath: string
+  lineNumber?: number
+  sourceCode?: string
+}
+
+// ---------------------------------------------------------------------------
+// Runtime helpers
+// ---------------------------------------------------------------------------
+
+export function isDenoProject(dir: string): boolean {
+  return existsSync(path.join(dir, 'deno.json')) || existsSync(path.join(dir, 'deno.jsonc'))
+}
+
+export function resolveRuntimeModule(cwd: string, baseName: string): string | null {
+  for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+    const candidate = path.join(cwd, `${baseName}${ext}`)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+function parseSignatureParams(signature?: string): string[] {
+  if (!signature) return []
+  const trimmed = signature.trim()
+  if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) return []
+  const body = trimmed.slice(1, -1).trim()
+  if (!body) return []
+  return body
+    .split(',')
+    .map(part => part.trim())
+    .filter(Boolean)
+    .map(part => part.replace(/^\.\.\./, '').split('=')[0].split(':')[0].replace(/\?/g, '').trim())
+    .filter(part => /^[$A-Z_][0-9A-Z_$]*$/i.test(part))
+}
+
+// ---------------------------------------------------------------------------
+// Argument building
+// ---------------------------------------------------------------------------
+
+export function buildToolArgs(input: unknown, tool?: ToolInfo): unknown[] {
+  if (input === undefined) return []
+  if (Array.isArray(input)) return input
+  if (input && typeof input === 'object') {
+    const argObject = input as Record<string, unknown>
+    const paramNames = parseSignatureParams(tool?.signature)
+    if (paramNames.length > 0 && paramNames.every(name => Object.prototype.hasOwnProperty.call(argObject, name))) {
+      return paramNames.map(name => argObject[name])
+    }
+    return [input]
+  }
+  return [input]
+}
+
+// ---------------------------------------------------------------------------
+// Subprocess execution
+// ---------------------------------------------------------------------------
+
+export function runToolInSubprocess(
+  toolsModulePath: string,
+  toolName: string,
+  args: unknown[],
+): Promise<RerunResult> {
+  return new Promise((resolve) => {
+    const startMs = Date.now()
+    const workerScript = new URL('../tool-runner-worker.js', import.meta.url).pathname
+    const projectDir = path.dirname(toolsModulePath)
+    const denoProject = isDenoProject(projectDir)
+
+    const nodeOptions = process.env.NODE_OPTIONS ?? ''
+    const tsxFlag = '--import tsx'
+    const childNodeOptions = nodeOptions.includes('tsx') ? nodeOptions : `${nodeOptions} ${tsxFlag}`.trim()
+    const childEnv = { ...process.env, NODE_OPTIONS: denoProject ? nodeOptions : childNodeOptions }
+
+    const runtime = denoProject ? 'deno' : process.execPath
+    const runtimeArgs = denoProject ? ['run', '--allow-all', workerScript] : [workerScript]
+
+    const child = spawn(runtime, runtimeArgs, {
+      env: childEnv,
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
+    let resultLine = ''
+    let stderr = ''
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      const text = chunk.toString()
+      for (const line of text.split('\n')) {
+        if (line.startsWith(RESULT_PREFIX)) {
+          resultLine = line.slice(RESULT_PREFIX.length)
+        } else if (line) {
+          process.stdout.write(line + '\n')
+        }
+      }
+    })
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      process.stderr.write(chunk)
+    })
+
+    child.on('close', () => {
+      const currentDurationMs = Date.now() - startMs
+      if (resultLine) {
+        try {
+          resolve({ ...JSON.parse(resultLine), currentDurationMs })
+          return
+        } catch { /* fall through */ }
+      }
+      resolve({ ok: false, error: stderr.trim() || 'Tool subprocess produced no output.', currentDurationMs })
+    })
+
+    child.on('error', (err) => {
+      const hint = denoProject && (err as NodeJS.ErrnoException).code === 'ENOENT'
+        ? ' (Deno project detected — ensure "deno" is installed and available in PATH)'
+        : ''
+      resolve({ ok: false, error: `Failed to spawn tool subprocess: ${err.message}${hint}`, currentDurationMs: Date.now() - startMs })
+    })
+
+    const payload = JSON.stringify({
+      toolsModulePath: pathToFileURL(toolsModulePath).pathname,
+      toolName,
+      args,
+    })
+    child.stdin.write(payload)
+    child.stdin.end()
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Tool scanning (static analysis of ed_tools.ts/js)
+// ---------------------------------------------------------------------------
+
+function resolveModulePath(fromDir: string, specifier: string): string | null {
+  if (!specifier.startsWith('.')) return null
+  const exts = ['.ts', '.tsx', '.js', '.jsx', '']
+  for (const ext of exts) {
+    const candidate = path.resolve(fromDir, specifier + ext)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+function lineAt(src: string, index: number): number {
+  return src.slice(0, index).split('\n').length
+}
+
+function extractSource(src: string, index: number): string {
+  const snippet = src.slice(index, index + 2000)
+  return snippet.length < 2000 ? snippet : snippet + '\n// (truncated)'
+}
+
+function findFunctionInSource(src: string, name: string): { isAsync: boolean; signature: string; lineNumber?: number; sourceCode?: string } {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  let m = src.match(new RegExp(`export\\s+(async\\s+)?function\\s+${escaped}\\s*(\\([^)]*\\))`))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!) }
+  m = src.match(new RegExp(`(?:^|\\n)\\s*(?:async\\s+)?function\\s+${escaped}\\s*(\\([^)]*\\))`, 'm'))
+  if (m) return {
+    isAsync: new RegExp(`async\\s+function\\s+${escaped}`).test(src),
+    signature: m[1],
+    lineNumber: lineAt(src, m.index!),
+    sourceCode: extractSource(src, m.index!),
+  }
+  m = src.match(new RegExp(`export\\s+const\\s+${escaped}\\s*=\\s*(async\\s*)?(\\([^)]*\\))\\s*=>`))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!) }
+  m = src.match(new RegExp(`(?:^|\\n)\\s*const\\s+${escaped}\\s*=\\s*(async\\s*)?(\\([^)]*\\))\\s*=>`, 'm'))
+  if (m) return { isAsync: !!m[1], signature: m[2], lineNumber: lineAt(src, m.index!) }
+  return { isAsync: false, signature: '()' }
+}
+
+function extractExportsFromSource(filePath: string): ParsedExport[] {
+  let src: string
+  try {
+    src = readFileSync(filePath, 'utf8')
+  } catch {
+    return []
+  }
+  const dir = path.dirname(filePath)
+  const results: ParsedExport[] = []
+
+  // 1. Direct: export [async] function name(params) { … }
+  for (const m of src.matchAll(/export\s+(async\s+)?function\s+(\w+)\s*(\([^)]*\))/g)) {
+    results.push({
+      name: m[2], isAsync: !!m[1], signature: m[3], filePath,
+      lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!),
+    })
+  }
+
+  // 2. Direct: export const name = [async] (params) => …
+  for (const m of src.matchAll(/export\s+const\s+(\w+)\s*=\s*(async\s*)?\(([^)]*)\)\s*=>/g)) {
+    results.push({
+      name: m[1], isAsync: !!m[2], signature: `(${m[3]})`, filePath,
+      lineNumber: lineAt(src, m.index!), sourceCode: extractSource(src, m.index!),
+    })
+  }
+
+  // 3. Named re-exports: export { X [as Y], … } from './module'
+  for (const m of src.matchAll(/export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g)) {
+    const modulePath = resolveModulePath(dir, m[2])
+    let moduleSrc = ''
+    try { if (modulePath) moduleSrc = readFileSync(modulePath, 'utf8') } catch { /* ignore */ }
+    for (const spec of m[1].split(',')) {
+      const parts = spec.trim().split(/\s+as\s+/)
+      const originalName = parts[0].trim()
+      const exportedName = (parts[1] ?? parts[0]).trim()
+      if (!exportedName || exportedName === 'default') continue
+      const info = moduleSrc ? findFunctionInSource(moduleSrc, originalName) : { isAsync: false, signature: '()' }
+      results.push({
+        name: exportedName, isAsync: info.isAsync, signature: info.signature,
+        filePath: modulePath ?? filePath, lineNumber: info.lineNumber, sourceCode: info.sourceCode,
+      })
+    }
+  }
+
+  // 4. Import + destructure: import { obj } from './m'  +  export const { a, b } = obj
+  for (const imp of src.matchAll(/import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g)) {
+    const importedNames = imp[1].split(',').map(s => {
+      const parts = s.trim().split(/\s+as\s+/)
+      return { original: parts[0].trim(), local: (parts[1] ?? parts[0]).trim() }
+    }).filter(n => n.local)
+    const modulePath = resolveModulePath(dir, imp[2])
+    for (const { local } of importedNames) {
+      const destructureRe = new RegExp(`export\\s+const\\s+\\{([^}]+)\\}\\s*=\\s*${local.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`)
+      const dm = src.match(destructureRe)
+      if (!dm) continue
+      let moduleSrc = ''
+      try { if (modulePath) moduleSrc = readFileSync(modulePath, 'utf8') } catch { /* ignore */ }
+      for (const member of dm[1].split(',')) {
+        const name = member.trim()
+        if (!name) continue
+        const info = moduleSrc ? findFunctionInSource(moduleSrc, name) : { isAsync: false, signature: '()' }
+        results.push({
+          name, isAsync: info.isAsync, signature: info.signature,
+          filePath: modulePath ?? filePath, lineNumber: info.lineNumber, sourceCode: info.sourceCode,
+        })
+      }
+    }
+  }
+
+  return results
+}
+
+export function scanTools(cwd: string): ToolInfo[] {
+  for (const candidate of [path.join(cwd, 'ed_tools.ts'), path.join(cwd, 'ed_tools.js')]) {
+    if (!existsSync(candidate)) continue
+    const exports = extractExportsFromSource(candidate)
+    if (exports.length > 0) {
+      return exports.map(e => ({
+        name: e.name, isAsync: e.isAsync, signature: e.signature,
+        filePath: e.filePath, lineNumber: e.lineNumber, sourceCode: e.sourceCode,
+      }))
+    }
+  }
+  return []
+}
+
+export function scanWorkflows(cwd: string): ToolInfo[] {
+  for (const candidate of [path.join(cwd, 'ed_workflows.ts'), path.join(cwd, 'ed_workflows.js')]) {
+    if (!existsSync(candidate)) continue
+    const exports = extractExportsFromSource(candidate)
+    if (exports.length > 0) {
+      return exports.map(e => ({
+        name: e.name, isAsync: e.isAsync, signature: e.signature,
+        filePath: e.filePath, lineNumber: e.lineNumber, sourceCode: e.sourceCode,
+      }))
+    }
+  }
+  return []
+}

package/src/http.ts

@@ -6,3 +6,5 @@
 export { setHttpRunContext, initHttpRunContext, getHttpRunContext } from './interceptors/telemetry-push.js'
 export { wrapTool } from './interceptors/tool.js'
 export { wrapAI } from './interceptors/workflow-ai.js'
+export { wrapDB, wrapPgClient, wrapKnex, wrapMongoCollection, wrapRedisClient } from './interceptors/db.js'
+export { initObservability, shutdownObservability, startTrace, wrapWorkflow } from './observability.js'

package/src/index.ts

@@ -71,6 +71,19 @@ export { interceptRandom, restoreRandom, interceptDateNow, restoreDateNow } from
 // AI interceptor (monkey-patch based)
 export { installAIInterceptor, uninstallAIInterceptor } from './interceptors/ai-interceptor.js'
 
+// Observability
+export { initObservability, shutdownObservability, startTrace, wrapWorkflow } from './observability.js'
+export type { ObservabilityOptions, ObservabilityHandle } from './observability.js'
+export { TelemetryBatcher } from './telemetry-batcher.js'
+export type { TelemetryBatcherOptions, TriggerSignal, TriggerStep } from './telemetry-batcher.js'
+export type { ObservabilityContext } from './interceptors/telemetry-push.js'
+export { checkToolAvailability, checkAIAvailability } from './portal-executor.js'
+export type { AvailabilityResult } from './portal-executor.js'
+
+// Socket connector (real-time backend communication)
+export { connectToBackend, disconnectFromBackend } from './socket-connector.js'
+export type { SocketConnectorOptions } from './socket-connector.js'
+
 // LLM proxy
 export { startLLMProxy, fetchCapturedTrace } from './proxy/llm-capture.js'
 
@@ -85,3 +98,8 @@ export type { RunWorkflowOptions, WorkflowRunResult } from './workflow-runner.js
 // Agent mid-trace replay
 export { serializeAgentState, deserializeAgentState, extractTaskOutputs, resolveTaskInput } from './core/agent-state.js'
 export type { AgentTask, AgentPlan, AgentState, AgentTaskStatus, AgentPlanStatus } from './types/agent.js'
+
+// Portal (remote rerun queue)
+export { startPortalServer } from './portal-server.js'
+export { executePortalTask } from './portal-executor.js'
+export type { PortalTask, PortalTaskResult, PortalServerOptions, PortalServerHandle, PortalStatus } from './types/portal.js'

package/src/interceptors/ai-interceptor.ts

@@ -1,6 +1,8 @@
 import { getCurrentTrace } from '../trace-adapter/context.js'
 import { getCaptureContext } from '../capture/recorder.js'
 import { rawDateNow } from './side-effects.js'
+import { getObservabilityContext, getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext } from './telemetry-push.js'
+import type { WorkflowEvent } from '../capture/event.js'
 
 type UsageInfo = { inputTokens?: number; outputTokens?: number; totalTokens?: number }
 
@@ -385,9 +387,12 @@ export function installAIInterceptor(): void {
 
     const provider = detectProvider(url)
     const traceAtCall = getCurrentTrace()
+    const obsCtx = getObservabilityContext()
 
-    // No match or no active trace: pass through unchanged
-    if (!provider || !traceAtCall) {
+    const httpCtx = getHttpRunContext()
+
+    // No match or no active context: pass through unchanged
+    if (!provider || (!traceAtCall && !obsCtx && !httpCtx)) {
       return originalFetch!(input, init)
     }
 
@@ -414,7 +419,106 @@ export function installAIInterceptor(): void {
 
     const ctx = getCaptureContext()
 
-    if (ctx) {
+    // Observability-only mode: no trace handle, no capture context — record via pushTelemetryEvent
+    if (!traceAtCall && !ctx && obsCtx) {
+      const id = obsCtx.nextId()
+      const start = rawDateNow()
+      const eventInput = { url, provider, model, prompt, messages }
+
+      const response = await originalFetch!(input, init)
+
+      if (isStreaming && response.body) {
+        const [streamForCaller, streamForRecorder] = response.body.tee()
+        bufferSSEStream(provider, streamForRecorder).then((completion) => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs })
+        }).catch(() => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+        })
+        return new Response(streamForCaller, { status: response.status, statusText: response.statusText, headers: response.headers })
+      }
+
+      try {
+        const cloned = response.clone()
+        const responseBody = await cloned.json() as Record<string, unknown>
+        const completion = extractCompletion(provider, responseBody)
+        const usage = extractUsage(provider, responseBody)
+        const durationMs = rawDateNow() - start
+        const event: WorkflowEvent = {
+          id, type: 'ai', name: model, input: eventInput, output: { completion },
+          timestamp: start, durationMs,
+          ...(usage ? { usage } : {}),
+        }
+        pushTelemetryEvent(event)
+      } catch {
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, timestamp: start, durationMs })
+      }
+
+      return response
+    }
+
+    // HTTP mode (no capture context): replay frozen AI events or execute live + push telemetry
+    if (!ctx && httpCtx) {
+      const id = httpCtx.nextId()
+      const eventInput = { url, provider, model, prompt, messages }
+
+      // Replay frozen step
+      const frozen = getHttpFrozenEvent(id)
+      if (frozen && frozen.type === 'ai') {
+        pushTelemetryEvent(frozen)
+        const frozenOutput = frozen.output as Record<string, unknown> | null
+        const completion = frozenOutput ? extractCompletion(provider, frozenOutput) : '(replayed)'
+
+        if (isStreaming) {
+          return new Response(synthesizeSSEStream(provider, completion), {
+            status: 200,
+            headers: { 'Content-Type': provider === 'gemini' ? 'application/json' : 'text/event-stream' },
+          })
+        }
+
+        const body = frozenOutput?.streamed === true
+          ? synthesizeCompletionJSON(provider, completion)
+          : (frozenOutput ?? synthesizeCompletionJSON(provider, completion))
+        return new Response(JSON.stringify(body), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      // Not frozen → execute live, push telemetry
+      const start = rawDateNow()
+      const response = await originalFetch!(input, init)
+
+      if (isStreaming && response.body) {
+        const [streamForCaller, streamForRecorder] = response.body.tee()
+        bufferSSEStream(provider, streamForRecorder).then((completion) => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs })
+        }).catch(() => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+        })
+        return new Response(streamForCaller, { status: response.status, statusText: response.statusText, headers: response.headers })
+      }
+
+      try {
+        const cloned = response.clone()
+        const responseBody = await cloned.json() as Record<string, unknown>
+        const completion = extractCompletion(provider, responseBody)
+        const usage = extractUsage(provider, responseBody)
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) })
+      } catch {
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, timestamp: start, durationMs })
+      }
+
+      return response
+    }
+
+    if (ctx && traceAtCall) {
       const { recorder, replay } = ctx
       const id = recorder.nextId()
       const start = rawDateNow()
@@ -505,7 +609,9 @@ export function installAIInterceptor(): void {
       return response
     }
 
-    // No capture context — original behaviour (outside of a workflow run)
+    // No capture context — original behaviour (trace handle only, outside of a workflow run)
+    if (!traceAtCall) return originalFetch!(input, init)
+
     const response = await originalFetch!(input, init)
 
     if (isStreaming && response.body) {

package/src/interceptors/db-auto.ts

@@ -1,4 +1,7 @@
 import { getCaptureContext } from '../capture/recorder.js'
+import { getCurrentTrace } from '../trace-adapter/context.js'
+import { rawDateNow } from './side-effects.js'
+import { getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
 
 type AnyFn = (...args: unknown[]) => unknown
 
@@ -10,6 +13,14 @@ interface MethodPatch {
 
 const appliedPatches: MethodPatch[] = []
 
+function toTraceArgs(input: unknown): Record<string, unknown> | undefined {
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    return input as Record<string, unknown>
+  }
+  if (input === undefined) return undefined
+  return { value: input }
+}
+
 function wrapProtoMethod(proto: object, method: string, eventName: string): void {
   const p = proto as Record<string, unknown>
   if (typeof p[method] !== 'function') return
@@ -24,58 +35,143 @@ function wrapProtoMethod(proto: object, method: string, eventName: string): void
     }
 
     const ctx = getCaptureContext()
-    if (!ctx) return original.apply(this, args)
+    const httpCtx = getHttpRunContext()
+    const obsCtx = getObservabilityContext()
+    const input = args.length === 1 ? args[0] : args
+
+    if (!ctx && !httpCtx && !obsCtx) return original.apply(this, args)
+
+    // Observability-only mode: record and push, no mocks/replay
+    if (!ctx && !httpCtx && obsCtx) {
+      const id = obsCtx.nextId()
+      const start = rawDateNow()
+
+      let result: unknown
+      try {
+        result = original.apply(this, args)
+      } catch (err) {
+        pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+        throw err
+      }
+
+      if (result != null && typeof (result as Promise<unknown>).then === 'function') {
+        return (result as Promise<unknown>)
+          .then((output: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output, timestamp: start, durationMs: rawDateNow() - start })
+            return output
+          })
+          .catch((err: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+            throw err
+          })
+      }
+
+      pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: result, timestamp: start, durationMs: rawDateNow() - start })
+      return result
+    }
 
-    const { recorder, replay } = ctx
+    // 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 === 'db') {
+        pushTelemetryEvent(frozen)
+        return Promise.resolve(frozen.output)
+      }
+
+      // Not frozen → execute live, push telemetry
+      const start = rawDateNow()
+
+      let result: unknown
+      try {
+        result = original.apply(this, args)
+      } catch (err) {
+        pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+        throw err
+      }
+
+      if (result != null && typeof (result as Promise<unknown>).then === 'function') {
+        return (result as Promise<unknown>)
+          .then((output: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output, timestamp: start, durationMs: rawDateNow() - start })
+            return output
+          })
+          .catch((err: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+            throw err
+          })
+      }
+
+      pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: result, timestamp: start, durationMs: rawDateNow() - start })
+      return result
+    }
+
+    // Capture mode (enhanced with telemetry + TraceHandle)
+    const trace = getCurrentTrace()
+    const { recorder, replay } = ctx!
     const id = recorder.nextId()
 
     if (replay.shouldReplay(id)) {
       const historicalEvent = replay.getRecordedEvent(id)
       if (historicalEvent) recorder.record(historicalEvent)
-      return Promise.resolve(replay.getRecordedResult(id))
+      if (httpCtx) pushTelemetryEvent(historicalEvent ?? { id, type: 'db', name: eventName, input, output: null, timestamp: rawDateNow(), durationMs: 0 })
+      const replayed = replay.getRecordedResult(id)
+      if (trace && typeof trace.recordToolCall === 'function') {
+        trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: replayed, workflowEventId: id })
+      }
+      return Promise.resolve(replayed)
     }
 
-    const start = Date.now()
-    const input = args.length === 1 ? args[0] : args
+    const start = rawDateNow()
 
     let result: unknown
     try {
       result = original.apply(this, args)
     } catch (err) {
-      recorder.record({
-        id, type: 'db', name: eventName,
-        input, output: { error: String(err) },
-        timestamp: start, durationMs: Date.now() - start,
-      })
+      const durationMs = rawDateNow() - start
+      const event = { id, type: 'db' as const, name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs }
+      recorder.record(event)
+      if (httpCtx) pushTelemetryEvent(event)
+      if (trace && typeof trace.recordToolCall === 'function') {
+        trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: { error: String(err) }, workflowEventId: id, durationMs })
+      }
       throw err
     }
 
     if (result != null && typeof (result as Promise<unknown>).then === 'function') {
       return (result as Promise<unknown>)
         .then((output: unknown) => {
-          recorder.record({
-            id, type: 'db', name: eventName,
-            input, output,
-            timestamp: start, durationMs: Date.now() - start,
-          })
+          const durationMs = rawDateNow() - start
+          const event = { id, type: 'db' as const, name: eventName, input, output, timestamp: start, durationMs }
+          recorder.record(event)
+          if (httpCtx) pushTelemetryEvent(event)
+          if (trace && typeof trace.recordToolCall === 'function') {
+            trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: output, workflowEventId: id, durationMs })
+          }
           return output
         })
         .catch((err: unknown) => {
-          recorder.record({
-            id, type: 'db', name: eventName,
-            input, output: { error: String(err) },
-            timestamp: start, durationMs: Date.now() - start,
-          })
+          const durationMs = rawDateNow() - start
+          const event = { id, type: 'db' as const, name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs }
+          recorder.record(event)
+          if (httpCtx) pushTelemetryEvent(event)
+          if (trace && typeof trace.recordToolCall === 'function') {
+            trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: { error: String(err) }, workflowEventId: id, durationMs })
+          }
           throw err
         })
     }
 
     // Sync return (rare for DB calls)
-    recorder.record({
-      id, type: 'db', name: eventName,
-      input, output: result,
-      timestamp: start, durationMs: Date.now() - start,
-    })
+    const durationMs = rawDateNow() - start
+    const event = { id, type: 'db' as const, name: eventName, input, output: result, timestamp: start, durationMs }
+    recorder.record(event)
+    if (httpCtx) pushTelemetryEvent(event)
+    if (trace && typeof trace.recordToolCall === 'function') {
+      trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result, workflowEventId: id, durationMs })
+    }
     return result
   }
 }