elasticdash-sdk 0.2.0

package/src/socket-connector.ts

@@ -0,0 +1,117 @@
+import { io, Socket } from 'socket.io-client'
+import type { PortalTask, PortalTaskResult } from './types/portal.js'
+import type { TriggerSignal } from './telemetry-batcher.js'
+import { executePortalTask } from './portal-executor.js'
+import { executeTrigger } from './trigger-executor.js'
+import { scanTools, scanWorkflows } from './execution/tool-runner.js'
+import { debugLog } from './utils/debug.js'
+
+export interface SocketConnectorOptions {
+  serverUrl: string
+  apiKey?: string
+  sessionId: string
+}
+
+let socket: Socket | null = null
+
+/**
+ * Establish a persistent socket.io connection to the backend.
+ *
+ * The SDK registers its sessionId and available tools/workflows
+ * on connect. The backend can then push portal tasks and trigger signals
+ * to this SDK instance for execution.
+ *
+ * Auto-reconnects on disconnect with exponential backoff (1s–30s).
+ * Safe to call multiple times — subsequent calls return the existing socket.
+ */
+export function connectToBackend(options: SocketConnectorOptions): Socket {
+  if (socket?.connected) return socket
+  // If a socket exists but is disconnected/reconnecting, reuse it
+  if (socket) return socket
+
+  const { serverUrl, apiKey, sessionId } = options
+  const cwd = process.cwd()
+
+  socket = io(serverUrl, {
+    auth: {
+      ...(apiKey ? { apiKey } : {}),
+      sessionId,
+    },
+    transports: ['websocket', 'polling'],
+    reconnection: true,
+    reconnectionDelay: 1000,
+    reconnectionDelayMax: 30_000,
+  })
+
+  socket.on('connect', () => {
+    debugLog(`[elasticdash] Socket connected: ${socket!.id}`)
+    const tools = scanTools(cwd)
+    const workflows = scanWorkflows(cwd)
+    socket!.emit('register', {
+      sessionId,
+      tools: tools.map(t => t.name),
+      workflows: workflows.map(w => w.name),
+    })
+  })
+
+  socket.on('auth:ok', (data: { projectId: number }) => {
+    debugLog(`[elasticdash] Authenticated for project ${data.projectId}`)
+    socket!.emit('join', `observability:project:${data.projectId}`)
+  })
+
+  socket.on('portal:task', async (task: PortalTask, ack?: (result: PortalTaskResult) => void) => {
+    debugLog(`[elasticdash] Socket received portal task: ${task.taskId} type=${task.type} name=${task.name}`)
+    try {
+      const tools = scanTools(cwd)
+      const result = await executePortalTask(task, cwd, tools)
+      if (typeof ack === 'function') {
+        ack(result)
+      } else {
+        socket!.emit('portal:result', result)
+      }
+    } catch (e) {
+      const errorResult: PortalTaskResult = {
+        taskId: task.taskId,
+        ok: false,
+        output: null,
+        error: e instanceof Error ? e.message : String(e),
+        durationMs: 0,
+        metadata: task.metadata,
+      }
+      if (typeof ack === 'function') {
+        ack(errorResult)
+      } else {
+        socket!.emit('portal:result', errorResult)
+      }
+    }
+  })
+
+  socket.on('trigger', async (trigger: TriggerSignal) => {
+    debugLog(`[elasticdash] Socket received trigger: ${trigger.triggerId} steps=${trigger.steps.length} runs=${trigger.runCount}`)
+    try {
+      await executeTrigger(serverUrl, apiKey, trigger)
+    } catch (e) {
+      debugLog(`[elasticdash] Socket trigger execution failed: ${e instanceof Error ? e.message : String(e)}`)
+    }
+  })
+
+  socket.on('disconnect', (reason) => {
+    debugLog(`[elasticdash] Socket disconnected: ${reason}`)
+  })
+
+  socket.on('connect_error', (err) => {
+    debugLog(`[elasticdash] Socket connection error: ${err.message}`)
+  })
+
+  return socket
+}
+
+/**
+ * Disconnect from the backend and clean up the socket.
+ */
+export async function disconnectFromBackend(): Promise<void> {
+  if (socket) {
+    socket.disconnect()
+    socket = null
+  }
+}

package/src/telemetry-batcher.ts

@@ -0,0 +1,191 @@
+import { Readable } from 'node:stream'
+import { randomUUID } from 'node:crypto'
+import type { WorkflowEvent } from './capture/event.js'
+import { getOriginalFetch } from './interceptors/http.js'
+import { debugLog } from './utils/debug.js'
+import { notifyLicenseError } from './utils/license-error.js'
+import { redactPayload } from './utils/redact.js'
+
+export interface TriggerStep {
+  eventId: number
+  eventType: 'ai' | 'tool' | 'http' | 'db'
+  eventName: string
+  originalEventDbId: number
+  input: unknown
+  model?: string
+  provider?: string
+}
+
+export interface FrozenEvent {
+  id: number
+  type: string
+  name: string
+  input: unknown
+  output: unknown
+  timestamp: number
+  durationMs: number | null
+  streamed?: boolean
+  streamRaw?: string | null
+}
+
+export interface TriggerSignal {
+  triggerId: number
+  runCount: number
+  steps: TriggerStep[]
+  /** HTTP/DB events from the same trace to freeze (mock) during step reruns */
+  frozenEvents?: FrozenEvent[]
+}
+
+export interface TelemetryBatcherOptions {
+  serverUrl: string
+  apiKey?: string
+  sessionId: string
+  metadata?: Record<string, unknown>
+  batchIntervalMs?: number
+  maxBatchSize?: number
+  redactKeys?: string[]
+  onTrigger?: (trigger: TriggerSignal) => Promise<void>
+}
+
+export class TelemetryBatcher {
+  private buffer: WorkflowEvent[] = []
+  private timer: ReturnType<typeof setInterval> | null = null
+  private readonly serverUrl: string
+  private readonly apiKey: string | undefined
+  private readonly sessionId: string
+  private readonly metadata: Record<string, unknown> | undefined
+  private readonly maxBatchSize: number
+  private readonly redactKeys: string[]
+  private readonly onTrigger: ((trigger: TriggerSignal) => Promise<void>) | undefined
+  private shuttingDown = false
+
+  constructor(opts: TelemetryBatcherOptions) {
+    this.serverUrl = opts.serverUrl.replace(/\/$/, '')
+    this.apiKey = opts.apiKey
+    this.sessionId = opts.sessionId
+    this.metadata = opts.metadata
+    this.maxBatchSize = opts.maxBatchSize ?? 50
+    this.redactKeys = opts.redactKeys ?? []
+    this.onTrigger = opts.onTrigger
+
+    const intervalMs = opts.batchIntervalMs ?? 2000
+    this.timer = setInterval(() => { this.flush().catch(() => {}) }, intervalMs)
+    // Allow the process to exit even if the timer is still scheduled
+    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+      this.timer.unref()
+    }
+  }
+
+  enqueue(event: WorkflowEvent): void {
+    if (this.shuttingDown) return
+    const redacted = this.redactKeys.length > 0
+      ? { ...event, input: redactPayload(event.input, this.redactKeys), output: redactPayload(event.output, this.redactKeys) }
+      : event
+    this.buffer.push(redacted as WorkflowEvent)
+    if (this.buffer.length >= this.maxBatchSize) {
+      this.flush().catch(() => {})
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (this.buffer.length === 0) return
+    const batch = this.buffer.splice(0, this.buffer.length)
+    await this.send(batch, 0)
+  }
+
+  private async send(batch: WorkflowEvent[], attempt: number): Promise<void> {
+    if (!this.serverUrl) {
+      debugLog(`[elasticdash] Dropping ${batch.length} events: serverUrl is empty`)
+      return
+    }
+    const maxRetries = 3
+    const url = `${this.serverUrl}/api/observability/events`
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-Correlation-ID': randomUUID(),
+    }
+    if (this.apiKey) headers['Authorization'] = `Bearer ${this.apiKey}`
+
+    try {
+      // Stream the JSON body to avoid buffering large payloads (e.g. events
+      // with streamRaw can exceed 100 MB). Node.js fetch (undici) supports
+      // Readable as body and uses chunked Transfer-Encoding automatically.
+      const body = Readable.from(jsonStreamEvents(this.sessionId, batch, this.metadata))
+
+      const res = await getOriginalFetch()(url, {
+        method: 'POST',
+        headers,
+        body,
+        duplex: 'half',
+      })
+
+      if (res.status === 402) {
+        notifyLicenseError(res.status, 'telemetry')
+        debugLog(`[elasticdash] Dropping ${batch.length} events: no available license (402)`)
+        return
+      }
+
+      if (res.status === 429 || res.status >= 500) {
+        if (attempt < maxRetries) {
+          const delayMs = Math.pow(2, attempt) * 1000
+          debugLog(`[elasticdash] Telemetry flush failed (${res.status}), retrying in ${delayMs}ms (attempt ${attempt + 1}/${maxRetries})`)
+          await new Promise((r) => setTimeout(r, delayMs))
+          return this.send(batch, attempt + 1)
+        }
+        debugLog(`[elasticdash] Dropping ${batch.length} events after ${maxRetries} retries (last status: ${res.status})`)
+        return
+      }
+
+      debugLog(`[elasticdash] Flushed ${batch.length} events (status ${res.status})`)
+
+      // Parse response for trigger signal
+      if (res.ok && this.onTrigger) {
+        try {
+          const body = await res.json() as { trigger?: TriggerSignal }
+          if (body.trigger && typeof body.trigger.triggerId === 'number' && Array.isArray(body.trigger.steps)) {
+            debugLog(`[elasticdash] Trigger received: id=${body.trigger.triggerId} steps=${body.trigger.steps.length} runCount=${body.trigger.runCount}`)
+            // Fire-and-forget — don't block the flush pipeline
+            this.onTrigger(body.trigger).catch((err) => {
+              debugLog(`[elasticdash] Trigger execution failed: ${err instanceof Error ? err.message : String(err)}`)
+            })
+          }
+        } catch {
+          // Response parsing failed — not critical, ignore
+        }
+      }
+    } catch (err) {
+      if (attempt < maxRetries) {
+        const delayMs = Math.pow(2, attempt) * 1000
+        debugLog(`[elasticdash] Telemetry flush error, retrying in ${delayMs}ms (attempt ${attempt + 1}/${maxRetries})`)
+        await new Promise((r) => setTimeout(r, delayMs))
+        return this.send(batch, attempt + 1)
+      }
+      debugLog(`[elasticdash] Dropping ${batch.length} events after ${maxRetries} retries: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.shuttingDown) return
+    this.shuttingDown = true
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+    await this.flush()
+  }
+}
+
+/**
+ * Yields JSON fragments for the events payload without building a single
+ * giant string. Each event is serialized individually so the process never
+ * holds the full serialized body in memory at once.
+ */
+function* jsonStreamEvents(sessionId: string, events: WorkflowEvent[], metadata?: Record<string, unknown>): Generator<string> {
+  const metaPart = metadata ? `,"metadata":${JSON.stringify(metadata)}` : ''
+  yield `{"sessionId":${JSON.stringify(sessionId)}${metaPart},"events":[`
+  for (let i = 0; i < events.length; i++) {
+    if (i > 0) yield ','
+    yield JSON.stringify(events[i])
+  }
+  yield ']}'
+}

package/src/test-setup.ts

@@ -0,0 +1,16 @@
+/**
+ * Import this file in your AI test files to get:
+ *   - aiTest / beforeAll / afterAll / beforeEach / afterEach available as globals (TypeScript types + runtime)
+ *   - Custom matcher types (toHaveLLMStep, toCallTool, toMatchSemanticOutput)
+ *
+ * The CLI registers matchers at startup, so this import is for TypeScript
+ * type awareness only — no double-registration occurs at runtime.
+ */
+
+// Side-effect: populates globalThis.aiTest + brings declare global into scope
+import './core/registry.js'
+
+// Side-effect: brings declare module 'expect' augmentation into scope
+import './matchers/index.js'
+
+export {}

package/src/tool-registry.ts

@@ -0,0 +1,94 @@
+/**
+ * Global registry for tools defined via edTool().
+ *
+ * Tools registered here are discoverable for reruns regardless of which
+ * module they live in. The helper also applies wrapTool() so telemetry
+ * fires automatically — symmetric with the Python @ed_tool decorator.
+ */
+
+import { wrapTool } from './interceptors/tool.js'
+
+export interface RegisteredTool {
+  name: string
+  fn: (...args: unknown[]) => unknown | Promise<unknown>
+  wrapped: (...args: unknown[]) => Promise<unknown>
+  isAsync: boolean
+  signature: string
+  sourceFile: string | null
+  lineNumber: number | null
+}
+
+const _registry: Map<string, RegisteredTool> = new Map()
+
+export function getRegisteredTools(): RegisteredTool[] {
+  return Array.from(_registry.values())
+}
+
+export function getRegisteredTool(name: string): RegisteredTool | undefined {
+  return _registry.get(name)
+}
+
+export function clearToolRegistry(): void {
+  _registry.clear()
+}
+
+function inferCallerLocation(): { file: string | null; line: number | null } {
+  const stack = new Error().stack
+  if (!stack) return { file: null, line: null }
+  const lines = stack.split('\n')
+  for (let i = 2; i < lines.length; i++) {
+    const m = lines[i].match(/\((.*?):(\d+):\d+\)|at\s+(.*?):(\d+):\d+/)
+    if (!m) continue
+    const file = m[1] ?? m[3]
+    const line = parseInt(m[2] ?? m[4], 10)
+    if (file && !file.includes('tool-registry')) {
+      return { file: file.replace(/^file:\/\//, ''), line: isNaN(line) ? null : line }
+    }
+  }
+  return { file: null, line: null }
+}
+
+function inferSignature(fn: Function): string {
+  const src = fn.toString()
+  const m = src.match(/^[^(]*\(([^)]*)\)/)
+  if (!m) return '()'
+  const params = m[1]
+    .split(',')
+    .map(p => p.trim().split(/[\s=:]/)[0])
+    .filter(Boolean)
+  return `(${params.join(', ')})`
+}
+
+/**
+ * Register a function as a rerunnable tool.
+ *
+ *   export const myTool = edTool('my_tool', async (query: string) => { ... })
+ *
+ * The returned function is the telemetry-wrapped version, so calling it from
+ * normal code paths still produces traces. The CLI `run-tool` command and the
+ * ElasticDash MCP `run_tool` tool will resolve the original by name.
+ */
+export function edTool<Args extends unknown[], R>(
+  name: string,
+  fn: (...args: Args) => R | Promise<R>,
+): (...args: Args) => Promise<R> {
+  const isAsync = fn.constructor.name === 'AsyncFunction'
+  const signature = inferSignature(fn)
+  const { file, line } = inferCallerLocation()
+
+  const wrapped = wrapTool(name, fn as (...args: unknown[]) => Promise<R>) as unknown as (...args: Args) => Promise<R>
+
+  _registry.set(name, {
+    name,
+    fn: fn as RegisteredTool['fn'],
+    wrapped: wrapped as RegisteredTool['wrapped'],
+    isAsync,
+    signature,
+    sourceFile: file,
+    lineNumber: line,
+  })
+
+  return wrapped
+}
+
+export const defineTool = edTool

package/src/tool-runner-worker.ts

@@ -0,0 +1,244 @@
+// Mark this process as an Elasticdash worker before anything else runs
+;(globalThis as any).__ELASTICDASH_WORKER__ = true
+
+// Ensure .env is loaded in the worker subprocess
+import 'dotenv/config'
+
+/**
+ * tool-runner-worker.ts
+ *
+ * Subprocess entry point for running a single tool function in an isolated
+ * Node.js process, guaranteeing no stale ESM/tsx module cache.
+ *
+ * Protocol (via stdin/stdout):
+ *   stdin  — one JSON line: { toolsModulePath, toolName, args, frozenEvents? }
+ *   stdout — prefixed result line: __ELASTICDASH_RESULT__:{...json...}
+ *
+ * When frozenEvents are provided, sets up an HttpRunContext so that all
+ * freezable actions within the tool (wrapAI, wrapDB, and fetch-intercepted
+ * HTTP calls) will replay from frozen data instead of hitting real services.
+ */
+
+import { pathToFileURL } from 'node:url'
+
+const RESULT_PREFIX = '__ELASTICDASH_RESULT__:'
+
+function writeResult(result: unknown): Promise<void> {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(RESULT_PREFIX + JSON.stringify(result) + '\n', (err) =>
+      err ? reject(err) : resolve()
+    )
+  })
+}
+
+interface FrozenEvent {
+  id: number
+  type: string
+  name: string
+  input: unknown
+  output: unknown
+  timestamp: number
+  durationMs: number | null
+  streamed?: boolean
+  streamRaw?: string | null
+}
+
+/**
+ * Set up frozen event replay context.
+ *
+ * For HTTP events: uses **URL-based matching** via a fetch wrapper, which is
+ * robust against ID counter drift.
+ *
+ * For AI and DB events: uses the HttpRunContext frozen map with sequential
+ * ID-based matching. All freezable event types (AI + DB) are included in the
+ * map and re-indexed in original execution order, so the shared nextId()
+ * counter stays aligned across interleaved wrapAI and wrapDB calls.
+ */
+async function setupFrozenContext(frozenEvents: FrozenEvent[]): Promise<void> {
+  if (frozenEvents.length === 0) return
+
+  // Always install URL-based fetch replay for HTTP events — this is the
+  // reliable matching strategy for tool reruns in subprocesses.
+  installFrozenFetchFallback(frozenEvents)
+
+  // Set up HttpRunContext for all freezable event types (AI + DB).
+  // Both wrapAI and wrapDB call httpCtx.nextId() sequentially, so we must
+  // include all freezable types in the frozen map, re-indexed in original
+  // execution order, to keep the sequential counter aligned.
+  const freezableEvents = frozenEvents
+    .filter(e => e.type === 'ai' || e.type === 'db')
+    .sort((a, b) => a.id - b.id) // preserve original execution order
+  if (freezableEvents.length > 0) {
+    try {
+      const telemetryPush = await import('./interceptors/telemetry-push.js')
+      const workflowEvents = freezableEvents.map((e, i) => ({
+        id: i + 1,
+        type: e.type as 'ai' | 'db',
+        name: e.name,
+        input: e.input,
+        output: e.output,
+        timestamp: e.timestamp,
+        durationMs: e.durationMs ?? 0,
+        streamed: e.streamed,
+        streamRaw: e.streamRaw,
+      }))
+      telemetryPush.setHttpRunContext('frozen-rerun', '')
+      const ctx = telemetryPush.getHttpRunContext()
+      if (ctx) {
+        for (const e of workflowEvents) {
+          ctx.frozenEvents.set(e.id, e as any)
+        }
+      }
+    } catch {
+      // Frozen replay not available — tool will hit real services
+    }
+  }
+}
+
+/** Saved original fetch so we can restore after the tool runs. */
+let savedOriginalFetch: typeof globalThis.fetch | null = null
+
+function restoreFrozenFetch(): void {
+  if (savedOriginalFetch) {
+    globalThis.fetch = savedOriginalFetch
+    savedOriginalFetch = null
+  }
+}
+
+/**
+ * Intercept fetch for HTTP frozen events using URL-based matching.
+ * This is the primary replay mechanism for tool reruns — it matches
+ * by request URL rather than sequential ID, which is robust against
+ * ID counter drift from wrapTool/wrapAI consuming IDs.
+ */
+function installFrozenFetchFallback(frozenEvents: FrozenEvent[]): void {
+  const httpEvents = frozenEvents.filter(e => e.type === 'http')
+
+  const frozenUrls = httpEvents.map(e => {
+    const inp = e.input as Record<string, unknown> | null
+    return inp && typeof inp === 'object' && typeof inp.url === 'string' ? inp.url : '(no url)'
+  })
+  process.stderr.write(`[elasticdash-worker] Frozen HTTP events: ${httpEvents.length}, URLs: ${JSON.stringify(frozenUrls)}\n`)
+
+  savedOriginalFetch = globalThis.fetch
+  const originalFetch = globalThis.fetch
+  const usageCounts = new Map<string, number>()
+
+  globalThis.fetch = async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : (input as Request).url
+
+    const matches = httpEvents.filter(e => {
+      const frozenUrl = (e.input && typeof e.input === 'object' && 'url' in (e.input as Record<string, unknown>))
+        ? (e.input as Record<string, unknown>).url
+        : null
+      return frozenUrl === url
+    })
+
+    if (matches.length > 0) {
+      const callCount = usageCounts.get(url) || 0
+      const match = matches[Math.min(callCount, matches.length - 1)]
+      usageCounts.set(url, callCount + 1)
+
+      process.stderr.write(`[elasticdash-worker] Frozen replay: ${url}\n`)
+      const body = typeof match.output === 'string' ? match.output : JSON.stringify(match.output)
+      return new Response(body, {
+        status: 200,
+        headers: { 'Content-Type': 'application/json', 'X-Frozen': 'true' }
+      })
+    }
+
+    process.stderr.write(`[elasticdash-worker] Fetch pass-through (no frozen match): ${url}\n`)
+    try {
+      return await originalFetch(input, init)
+    } catch (e) {
+      process.stderr.write(`[elasticdash-worker] Fetch FAILED for ${url}: ${(e as Error).stack || (e as Error).message || String(e)}\n`)
+      throw e
+    }
+  }
+}
+
+async function main() {
+  const originalExit = process.exit.bind(process)
+
+  // Prevent the SDK's tryAutoInitHttpContext from triggering full observability
+  // or dashboard-mode initialization in this subprocess. The subprocess should
+  // only execute the tool — observability/dashboard contexts are set up
+  // explicitly via setupFrozenContext when frozen events are provided.
+  // Without this, inherited env vars cause initObservability() to install
+  // interceptors, socket connections, and heartbeats that conflict with
+  // the frozen replay setup and can cause "Invalid URL" errors from
+  // Langfuse/OTel trying to connect to servers during tool execution.
+  delete process.env.ELASTICDASH_API_URL
+  delete process.env.ELASTICDASH_SERVER
+
+  let raw = ''
+  for await (const chunk of process.stdin) {
+    raw += chunk
+  }
+
+  let payload: { toolsModulePath: string; toolName: string; args: unknown[]; frozenEvents?: FrozenEvent[] }
+  try {
+    payload = JSON.parse(raw)
+  } catch (e) {
+    await writeResult({ ok: false, error: `Invalid JSON input: ${(e as Error).message}` })
+    originalExit(1)
+    return
+  }
+
+  const { toolsModulePath, toolName, args, frozenEvents } = payload
+
+  // Set up frozen event context before running the tool.
+  // Uses URL-based matching for HTTP events (reliable for observability reruns)
+  // and ID-based matching for DB events.
+  const hasFrozen = frozenEvents && frozenEvents.length > 0
+  if (hasFrozen) {
+    await setupFrozenContext(frozenEvents)
+  }
+
+  try {
+    let mod: any
+    try {
+      mod = await import(pathToFileURL(toolsModulePath).href)
+    } catch (importErr) {
+      const ie = importErr as Error
+      await writeResult({ ok: false, error: `Failed to import tool module: ${ie.stack || ie.message}` })
+      originalExit(1)
+      return
+    }
+
+    // Registry first: covers tools defined via edTool() anywhere in the project,
+    // 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
+    try {
+      const reg = await import('./tool-registry.js')
+      const registered = reg.getRegisteredTool(toolName)
+      if (registered) fn = registered.wrapped
+    } 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 fn !== 'function') {
+      await writeResult({ ok: false, error: `"${toolName}" not found via edTool() registry or as an exported function in the module.` })
+      originalExit(1)
+      return
+    }
+
+    const currentOutput = await fn(...args)
+    await writeResult({ ok: true, currentOutput })
+    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 })
+    originalExit(1)
+  } finally {
+    if (hasFrozen) restoreFrozenFetch()
+  }
+}
+
+main()