elasticdash-sdk 0.2.5 → 0.2.7-beta

package/src/interceptors/db-auto.ts

@@ -13,6 +13,22 @@ interface MethodPatch {
 
 const appliedPatches: MethodPatch[] = []
 
+/**
+ * Bundler-opaque dynamic import for optional peer dependencies. Webpack /
+ * turbopack / rollup statically analyze `await import('<literal>')` and try
+ * to resolve the target at build time, which fails for consumers that don't
+ * have the optional peer installed (e.g. a Next.js app that doesn't use
+ * Postgres still gets "Module not found: Can't resolve 'pg'" because this
+ * file is reachable from its bundle). Routing the import through
+ * `new Function` hides the call from static analysis so resolution happens
+ * at runtime in Node, where missing modules throw and the caller's outer
+ * Promise.allSettled swallows the rejection — the SDK's intended behavior.
+ */
+const loadOptionalPeer = new Function(
+  'specifier',
+  'return import(specifier)',
+) as (specifier: string) => Promise<unknown>
+
 function toTraceArgs(input: unknown): Record<string, unknown> | undefined {
   if (input && typeof input === 'object' && !Array.isArray(input)) {
     return input as Record<string, unknown>
@@ -177,8 +193,7 @@ function wrapProtoMethod(proto: object, method: string, eventName: string): void
 }
 
 async function tryPatchPg(): Promise<void> {
-  // @ts-ignore — optional peer dependency
-  const pgMod = await import('pg') as Record<string, unknown>
+  const pgMod = (await loadOptionalPeer('pg')) as Record<string, unknown>
   const pg = (pgMod.default as Record<string, unknown> | undefined) ?? pgMod
   const Client = pg.Client as { prototype: object } | undefined
   // Patch Client.prototype only — Pool.query delegates to Client internally
@@ -188,8 +203,7 @@ async function tryPatchPg(): Promise<void> {
 }
 
 async function tryPatchMysql2(): Promise<void> {
-  // @ts-ignore — optional peer dependency
-  const mod = await import('mysql2/promise') as Record<string, unknown>
+  const mod = (await loadOptionalPeer('mysql2/promise')) as Record<string, unknown>
   const mysql2 = (mod.default as Record<string, unknown> | undefined) ?? mod
   const Connection = mysql2.Connection as { prototype: object } | undefined
   if (Connection?.prototype) {
@@ -199,8 +213,7 @@ async function tryPatchMysql2(): Promise<void> {
 }
 
 async function tryPatchMongodb(): Promise<void> {
-  // @ts-ignore — optional peer dependency
-  const mongMod = await import('mongodb') as Record<string, unknown>
+  const mongMod = (await loadOptionalPeer('mongodb')) as Record<string, unknown>
   const Collection = (
     mongMod.Collection ??
     (mongMod.default as Record<string, unknown> | undefined)?.Collection
@@ -213,8 +226,7 @@ async function tryPatchMongodb(): Promise<void> {
 }
 
 async function tryPatchIoredis(): Promise<void> {
-  // @ts-ignore — optional peer dependency
-  const mod = await import('ioredis') as Record<string, unknown>
+  const mod = (await loadOptionalPeer('ioredis')) as Record<string, unknown>
   const Redis = (mod.default ?? mod) as { prototype: object } | undefined
   if (Redis?.prototype) {
     wrapProtoMethod(Redis.prototype, 'call', 'redis.call')

package/src/interceptors/telemetry-push.ts

@@ -216,7 +216,7 @@ export function applyInboundMockConfig(req: unknown): void {
   if (!raw) return
 
   // Header format:
-  //   "gz1:<base64-gzip>" — current SDK (>=0.2.5) — gzipped JSON, used to
+  //   "gz1:<base64-gzip>" — current SDK (>=0.2.6) — gzipped JSON, used to
   //     stay under Node's default 8KB header limit when configs include
   //     large trace-derived outputs.
   //   "<base64-json>" — legacy plain base64 (back-compat with earlier SDKs).

package/src/tool-runner-worker.ts

@@ -23,6 +23,13 @@ import { pathToFileURL } from 'node:url'
 
 const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
 
+const WORKER_START_MS = Date.now()
+function stage(name: string, extra?: Record<string, unknown>): void {
+  if (process.env.ELASTICDASH_DEBUG !== '1') return
+  const tail = extra ? ' ' + Object.entries(extra).map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`).join(' ') : ''
+  process.stderr.write(`[elasticdash-worker tool] stage=${name} pid=${process.pid} elapsedMs=${Date.now() - WORKER_START_MS}${tail}\n`)
+}
+
 function writeResult(result: unknown): Promise<void> {
   return new Promise((resolve, reject) => {
     process.stdout.write(RESULT_PREFIX + JSON.stringify(result) + '\n', (err) =>
@@ -158,6 +165,7 @@ function installFrozenFetchFallback(frozenEvents: FrozenEvent[]): void {
 }
 
 async function main() {
+  stage('boot')
   const originalExit = process.exit.bind(process)
 
   // Prevent the SDK's tryAutoInitHttpContext from triggering full observability
@@ -175,6 +183,7 @@ async function main() {
   for await (const chunk of process.stdin) {
     raw += chunk
   }
+  stage('stdin-eof', { bytes: raw.length })
 
   let payload: { toolsModulePath: string; toolName: string; args: unknown[]; frozenEvents?: FrozenEvent[] }
   try {
@@ -184,6 +193,7 @@ async function main() {
     originalExit(1)
     return
   }
+  stage('payload-parsed')
 
   const { toolsModulePath, toolName, args, frozenEvents } = payload
 
@@ -193,12 +203,16 @@ async function main() {
   const hasFrozen = frozenEvents && frozenEvents.length > 0
   if (hasFrozen) {
     await setupFrozenContext(frozenEvents)
+    stage('frozen-context-ready', { count: frozenEvents.length })
+  } else {
+    stage('frozen-context-skipped')
   }
 
   try {
     let mod: any
     try {
       mod = await import(pathToFileURL(toolsModulePath).href)
+      stage('tool-module-imported')
     } catch (importErr) {
       const ie = importErr as Error
       await writeResult({ ok: false, error: `Failed to import tool module: ${ie.stack || ie.message}` })
@@ -210,31 +224,37 @@ async function main() {
     // as long as their containing module is reachable from toolsModulePath's
     // import graph. Falls back to ed_tools-style module export lookup.
     let fn: ((...a: unknown[]) => unknown) | undefined
+    let resolvedVia = 'none'
     try {
       const reg = await import('./tool-registry.js')
       const registered = reg.getRegisteredTool(toolName)
-      if (registered) fn = registered.wrapped
+      if (registered) { fn = registered.wrapped; resolvedVia = 'registry' }
     } catch {
       // Registry module not available (older SDK build); fall through to export lookup.
     }
     if (!fn) {
       const exported = mod[toolName]
-      if (typeof exported === 'function') fn = exported
+      if (typeof exported === 'function') { fn = exported; resolvedVia = 'module-export' }
     }
     if (typeof fn !== 'function') {
       await writeResult({ ok: false, error: `"${toolName}" not found via edTool() registry or as an exported function in the module.` })
       originalExit(1)
       return
     }
+    stage('tool-resolved', { tool: toolName, via: resolvedVia })
 
+    stage('tool-call-start', { tool: toolName })
     const currentOutput = await fn(...args)
+    stage('tool-call-end', { tool: toolName })
     await writeResult({ ok: true, currentOutput })
+    stage('result-written')
     originalExit(0)
   } catch (e) {
     const err = e as Error
     const errorMsg = err.stack || err.message || String(e)
     process.stderr.write(`[elasticdash-worker] Tool execution failed:\n${errorMsg}\n`)
     await writeResult({ ok: false, error: errorMsg })
+    stage('result-written', { ok: false })
     originalExit(1)
   } finally {
     if (hasFrozen) restoreFrozenFetch()

package/src/trigger-executor.ts

@@ -101,6 +101,8 @@ export async function executeTrigger(
       const runs: StepRunResult[] = []
 
       for (let i = 0; i < trigger.runCount; i++) {
+        const runStart = Date.now()
+        debugLog(`[elasticdash] Trigger ${trigger.triggerId} step=${stepIndex + 1}/${totalSteps} name=${step.eventName} run=${i + 1}/${trigger.runCount} phase=start`)
         const result = await executePortalTask(
           {
             taskId: `trigger-${trigger.triggerId}-${step.eventName}-${i}`,
@@ -130,7 +132,7 @@ export async function executeTrigger(
           usageTotalTokens: result.usage?.totalTokens,
         })
 
-        debugLog(`[elasticdash] Trigger ${trigger.triggerId} step=${step.eventName} run=${i} ok=${result.ok}`)
+        debugLog(`[elasticdash] Trigger ${trigger.triggerId} step=${stepIndex + 1}/${totalSteps} name=${step.eventName} run=${i + 1}/${trigger.runCount} phase=done ok=${result.ok} elapsedMs=${Date.now() - runStart}`)
       }
 
       stepResult = {

package/src/workflow-runner-worker.ts

@@ -43,6 +43,13 @@ async function readStdin(): Promise<string> {
 
 const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
 
+const WORKER_START_MS = Date.now()
+function stage(name: string, extra?: Record<string, unknown>): void {
+  if (process.env.ELASTICDASH_DEBUG !== '1') return
+  const tail = extra ? ' ' + Object.entries(extra).map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`).join(' ') : ''
+  process.stderr.write(`[elasticdash-worker workflow] stage=${name} pid=${process.pid} elapsedMs=${Date.now() - WORKER_START_MS}${tail}\n`)
+}
+
 const IS_DENO = typeof (globalThis as any).Deno !== 'undefined'
 
 /** Write the result JSON to fd3 pipe (Node.js) or a prefixed stdout line (Deno).
@@ -215,10 +222,12 @@ async function loadAndWrapTools(
 }
 
 async function main() {
+  stage('boot')
   // Keep a reference to the real process.exit so we can call it after flushing stdout.
   const originalExit = process.exit.bind(process)
 
   const raw = await readStdin()
+  stage('stdin-eof', { bytes: raw.length })
 
   let payload: {
     workflowsModulePath: string
@@ -249,6 +258,7 @@ async function main() {
     originalExit(1)
     return
   }
+  stage('payload-parsed')
 
   const { workflowsModulePath, toolsModulePath, workflowName, args, input, replayMode = false, checkpoint = 0, history = [], agentState, toolMockConfig, aiMockConfig, promptMockConfig, userPromptMockConfig, strict } = payload
 
@@ -273,6 +283,9 @@ async function main() {
       originalValues[name] = globals[name]
       globals[name] = fn
     }
+    stage('tools-wrapped', { count: Object.keys(wrappedTools).length })
+  } else {
+    stage('tools-wrapped-skipped')
   }
 
   // Intercept process.exit() so that workflows that call it internally (e.g. agent
@@ -305,20 +318,25 @@ async function main() {
     interceptFetch()
     interceptRandom()
     interceptDateNow()
+    stage('interceptors-installed')
 
     try {
       if (agentState) {
         // Agent mid-trace resumption path: load ed_agents and resume from saved state
         const agentsModulePath = workflowsModulePath.replace(/ed_workflows(\.[^.]+)?$/, 'ed_agents$1')
         const agentsMod = await import(pathToFileURL(agentsModulePath).href)
+        stage('agents-module-imported')
         if (typeof agentsMod.resumeAgentFromTrace !== 'function') {
           throw new Error(`"resumeAgentFromTrace" is not an exported function in ${agentsModulePath}`)
         }
+        stage('workflow-call-start', { mode: 'agent-resume' })
         currentOutput = await (agentsMod.resumeAgentFromTrace as (s: AgentState) => Promise<unknown>)(agentState)
+        stage('workflow-call-end', { mode: 'agent-resume' })
         console.error('[worker] resumeAgentFromTrace resolved, currentOutput:', currentOutput)
       } else {
         // Standard workflow path
         const workflowsMod = await import(pathToFileURL(workflowsModulePath).href)
+        stage('workflow-module-imported')
         const workflowFn = workflowsMod[workflowName]
         if (typeof workflowFn !== 'function') {
           ;(process as NodeJS.Process).exit = originalExit
@@ -328,7 +346,9 @@ async function main() {
         }
         // Standardize workflow argument resolution: always pass [input] if args is empty
         const callArgs = args.length ? args : [input]
+        stage('workflow-call-start', { workflow: workflowName })
         currentOutput = await (workflowFn as (...a: unknown[]) => unknown)(...callArgs)
+        stage('workflow-call-end', { workflow: workflowName })
         console.error('[worker] workflowFn resolved, currentOutput:', currentOutput)  // stderr so it's visible
       }
     } finally {
@@ -369,6 +389,7 @@ async function main() {
   }
 
   await recorder.flush()
+  stage('recorder-flushed')
 
   const traceData = {
     steps: context.trace.getSteps(),
@@ -380,9 +401,11 @@ async function main() {
 
   if (workflowError) {
     await writeResult({ ok: false, error: workflowError.message ?? String(workflowError), ...traceData })
+    stage('result-written', { ok: false })
     originalExit(pendingExitCode ?? 1)
   } else {
     await writeResult({ ok: true, currentOutput, ...traceData })
+    stage('result-written', { ok: true })
     originalExit(pendingExitCode ?? 0)
   }
 }