@openbox-ai/openbox-mastra-sdk 0.1.0

package/dist/otel/setup-openbox-opentelemetry.js

@@ -0,0 +1,2249 @@
+import { randomUUID } from "node:crypto";
+import { createRequire, syncBuiltinESMExports } from "node:module";
+import { context, trace } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+  getPendingApproval,
+  isActivityApproved
+} from "../governance/approval-registry.js";
+import { getOpenBoxExecutionContext } from "../governance/context.js";
+import { OpenBoxSpanProcessor } from "../span/index.js";
+import {
+  ApprovalPendingError,
+  GovernanceHaltError,
+  Verdict,
+  WorkflowEventType
+} from "../types/index.js";
+const DB_INSTRUMENTATION_NAMES = /* @__PURE__ */ new Map([
+  ["pg", ["@opentelemetry/instrumentation-pg"]],
+  ["postgres", ["@opentelemetry/instrumentation-pg"]],
+  ["mysql", ["@opentelemetry/instrumentation-mysql"]],
+  ["mysql2", ["@opentelemetry/instrumentation-mysql2"]],
+  ["mongodb", ["@opentelemetry/instrumentation-mongodb"]],
+  ["mongoose", ["@opentelemetry/instrumentation-mongoose"]],
+  ["redis", ["@opentelemetry/instrumentation-redis"]],
+  ["ioredis", ["@opentelemetry/instrumentation-ioredis"]],
+  ["knex", ["@opentelemetry/instrumentation-knex"]],
+  ["oracledb", ["@opentelemetry/instrumentation-oracledb"]],
+  ["cassandra", ["@opentelemetry/instrumentation-cassandra-driver"]],
+  ["tedious", ["@opentelemetry/instrumentation-tedious"]]
+]);
+const HTTP_INSTRUMENTATION_DEFINITIONS = [
+  {
+    exportName: "HttpInstrumentation",
+    moduleName: "@opentelemetry/instrumentation-http"
+  },
+  {
+    exportName: "UndiciInstrumentation",
+    moduleName: "@opentelemetry/instrumentation-undici"
+  }
+];
+const DB_INSTRUMENTATION_DEFINITIONS = /* @__PURE__ */ new Map([
+  [
+    "@opentelemetry/instrumentation-pg",
+    {
+      exportName: "PgInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-pg"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-mysql",
+    {
+      exportName: "MySQLInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-mysql"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-mysql2",
+    {
+      exportName: "MySQL2Instrumentation",
+      moduleName: "@opentelemetry/instrumentation-mysql2"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-mongodb",
+    {
+      exportName: "MongoDBInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-mongodb"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-mongoose",
+    {
+      exportName: "MongooseInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-mongoose"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-redis",
+    {
+      exportName: "RedisInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-redis"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-ioredis",
+    {
+      exportName: "IORedisInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-ioredis"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-knex",
+    {
+      exportName: "KnexInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-knex"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-oracledb",
+    {
+      exportName: "OracleInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-oracledb"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-cassandra-driver",
+    {
+      exportName: "CassandraDriverInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-cassandra-driver"
+    }
+  ],
+  [
+    "@opentelemetry/instrumentation-tedious",
+    {
+      exportName: "TediousInstrumentation",
+      moduleName: "@opentelemetry/instrumentation-tedious"
+    }
+  ]
+]);
+const DEFAULT_FILE_SKIP_PATTERNS = [
+  "/dev/",
+  "/proc/",
+  "/sys/",
+  "\\\\?\\pipe\\",
+  "__pycache__",
+  ".pyc",
+  ".pyo",
+  ".so",
+  ".dylib"
+];
+const TEXT_CONTENT_TYPES = [
+  "text/",
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/x-www-form-urlencoded"
+];
+const APPROVAL_ABORT_PREFIX = "__openbox_approval__:";
+let activeFetchRestore;
+let activeFileRestore;
+let activeHookGovernanceRuntime;
+let activeUnregister;
+function setupOpenBoxOpenTelemetry({
+  captureHttpBodies = true,
+  dbLibraries,
+  fileSkipPatterns = DEFAULT_FILE_SKIP_PATTERNS,
+  governanceClient,
+  ignoredUrls = [],
+  instrumentDatabases = true,
+  instrumentFileIo = false,
+  onHookApiError,
+  spanProcessor
+}) {
+  teardownActiveTelemetry();
+  const require2 = createRequire(import.meta.url);
+  const { registerInstrumentations } = require2(
+    "@opentelemetry/instrumentation"
+  );
+  const tracerProvider = new NodeTracerProvider({
+    spanProcessors: [spanProcessor]
+  });
+  tracerProvider.register();
+  const hookGovernance = governanceClient ? {
+    client: governanceClient,
+    onApiError: onHookApiError ?? governanceClient.onApiError ?? "fail_open",
+    spanProcessor
+  } : void 0;
+  activeHookGovernanceRuntime = hookGovernance;
+  const instrumentations = [
+    ...selectHttpInstrumentations(ignoredUrls, captureHttpBodies),
+    ...selectDatabaseInstrumentations(
+      instrumentDatabases,
+      dbLibraries,
+      hookGovernance
+    ),
+    ...selectFileInstrumentation(instrumentFileIo, fileSkipPatterns)
+  ];
+  activeUnregister = registerInstrumentations({
+    instrumentations,
+    tracerProvider
+  });
+  if (captureHttpBodies) {
+    activeFetchRestore = patchFetch(
+      spanProcessor,
+      ignoredUrls,
+      hookGovernance
+    );
+  }
+  if (instrumentFileIo) {
+    activeFileRestore = patchFileIo(fileSkipPatterns, hookGovernance);
+  }
+  return {
+    instrumentations,
+    async shutdown() {
+      teardownActiveTelemetry();
+      await tracerProvider.shutdown();
+      disableGlobalTraceApi();
+    },
+    tracerProvider
+  };
+}
+function traced(fn, options = {}) {
+  return async function openBoxTraced(...args) {
+    const hookGovernance = activeHookGovernanceRuntime;
+    if (!hookGovernance) {
+      return fn.apply(this, args);
+    }
+    const functionName = options.name ?? fn.name ?? "anonymous";
+    const moduleName = options.module ?? "unknown";
+    const tracer = trace.getTracer(options.tracerName ?? "openbox.tracing");
+    return tracer.startActiveSpan(`function.${functionName}`, async (span) => {
+      const spanContext = span.spanContext();
+      const startTimeNs = Date.now() * 1e6;
+      const hookSpanId = normalizeHexId(void 0, 16);
+      span.setAttribute("code.function", functionName);
+      span.setAttribute("code.namespace", moduleName);
+      let fnStarted = false;
+      try {
+        await evaluateHookGovernance(hookGovernance, {
+          activeSpan: span,
+          hookTrigger: {
+            attribute_key_identifiers: ["code.function", "code.namespace"],
+            ...options.captureArgs ? { args: sanitizeForGovernancePayload(args) } : {},
+            function: functionName,
+            module: moduleName,
+            stage: "started",
+            type: "function_call"
+          },
+          span: createHookSpan({
+            attributes: {
+              "code.function": functionName,
+              "code.namespace": moduleName
+            },
+            endTimeNs: startTimeNs,
+            functionArgs: options.captureArgs ? args : void 0,
+            functionModule: moduleName,
+            functionName,
+            hookType: "function_call",
+            kind: "INTERNAL",
+            name: `function.${functionName}`,
+            parentSpanId: spanContext.spanId,
+            semanticType: "function_call",
+            spanId: hookSpanId,
+            stage: "started",
+            startTimeNs,
+            traceId: spanContext.traceId
+          }),
+          stage: "started",
+          traceId: spanContext.traceId
+        });
+        fnStarted = true;
+        const result = await fn.apply(this, args);
+        const endTimeNs = Date.now() * 1e6;
+        await evaluateHookGovernance(hookGovernance, {
+          activeSpan: span,
+          hookTrigger: {
+            attribute_key_identifiers: ["code.function", "code.namespace"],
+            function: functionName,
+            module: moduleName,
+            ...options.captureResult ? { result: sanitizeForGovernancePayload(result) } : {},
+            stage: "completed",
+            type: "function_call"
+          },
+          span: createHookSpan({
+            attributes: {
+              "code.function": functionName,
+              "code.namespace": moduleName
+            },
+            endTimeNs,
+            functionModule: moduleName,
+            functionName,
+            functionResult: options.captureResult ? result : void 0,
+            hookType: "function_call",
+            kind: "INTERNAL",
+            name: `function.${functionName}`,
+            parentSpanId: spanContext.spanId,
+            semanticType: "function_call",
+            spanId: hookSpanId,
+            stage: "completed",
+            startTimeNs,
+            traceId: spanContext.traceId
+          }),
+          stage: "completed",
+          traceId: spanContext.traceId
+        });
+        return result;
+      } catch (error) {
+        if (fnStarted) {
+          const endTimeNs = Date.now() * 1e6;
+          await evaluateHookGovernance(hookGovernance, {
+            activeSpan: span,
+            hookTrigger: {
+              attribute_key_identifiers: ["code.function", "code.namespace"],
+              error: error instanceof Error ? error.message : String(error),
+              function: functionName,
+              module: moduleName,
+              stage: "completed",
+              type: "function_call"
+            },
+            span: createHookSpan({
+              attributes: {
+                "code.function": functionName,
+                "code.namespace": moduleName
+              },
+              endTimeNs,
+              error: error instanceof Error ? error.message : String(error),
+              functionModule: moduleName,
+              functionName,
+              hookType: "function_call",
+              kind: "INTERNAL",
+              name: `function.${functionName}`,
+              parentSpanId: spanContext.spanId,
+              semanticType: "function_call",
+              spanId: hookSpanId,
+              stage: "completed",
+              startTimeNs,
+              traceId: spanContext.traceId
+            }),
+            stage: "completed",
+            traceId: spanContext.traceId
+          });
+        }
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
+function selectHttpInstrumentations(ignoredUrls, captureHttpBodies) {
+  if (!captureHttpBodies) {
+    return [];
+  }
+  return HTTP_INSTRUMENTATION_DEFINITIONS.map((definition) => {
+    if (definition.moduleName === "@opentelemetry/instrumentation-http") {
+      return loadInstrumentation(definition, {
+        disableIncomingRequestInstrumentation: true,
+        headersToSpanAttributes: {},
+        ignoreOutgoingRequestHook: (request) => {
+          const url = buildRequestUrl(request);
+          return shouldIgnoreUrl(url, ignoredUrls);
+        }
+      });
+    }
+    return loadInstrumentation(definition);
+  });
+}
+function selectDatabaseInstrumentations(instrumentDatabases, dbLibraries, hookGovernance) {
+  if (!instrumentDatabases) {
+    return [];
+  }
+  const enabledNames = dbLibraries && dbLibraries.size > 0 ? new Set(
+    [...dbLibraries].flatMap(
+      (name) => DB_INSTRUMENTATION_NAMES.get(name.toLowerCase()) ?? []
+    )
+  ) : void 0;
+  const definitions = enabledNames ? [...enabledNames].map((name) => DB_INSTRUMENTATION_DEFINITIONS.get(name)).filter(
+    (definition) => definition !== void 0
+  ) : [...DB_INSTRUMENTATION_DEFINITIONS.values()];
+  return definitions.map(
+    (definition) => loadInstrumentation(
+      definition,
+      createDatabaseInstrumentationConfig(
+        definition.moduleName,
+        hookGovernance
+      )
+    )
+  );
+}
+function selectFileInstrumentation(instrumentFileIo, fileSkipPatterns) {
+  if (!instrumentFileIo) {
+    return [];
+  }
+  const require2 = createRequire(import.meta.url);
+  const { FsInstrumentation } = require2(
+    "@opentelemetry/instrumentation-fs"
+  );
+  const instrumentation = new FsInstrumentation({
+    createHook(_functionName, info) {
+      const filePath = getFilePathFromArgs(info.args);
+      if (!filePath) {
+        return true;
+      }
+      if (fileSkipPatterns.some((pattern) => filePath.includes(pattern))) {
+        return false;
+      }
+      return !filePath.startsWith("/dev/");
+    },
+    requireParentSpan: true
+  });
+  return [instrumentation];
+}
+function createDatabaseInstrumentationConfig(moduleName, hookGovernance) {
+  if (!hookGovernance) {
+    return void 0;
+  }
+  const queryStartTimes = /* @__PURE__ */ new Map();
+  const emitStarted = (span, details) => {
+    const spanId = span.spanContext().spanId;
+    const startTimeNs = Date.now() * 1e6;
+    const hookSpanId = normalizeHexId(void 0, 16);
+    queryStartTimes.set(spanId, {
+      hookSpanId,
+      startTimeNs
+    });
+    void emitDatabaseHookGovernance({
+      details,
+      hookSpanId,
+      hookGovernance,
+      span,
+      stage: "started",
+      startTimeNs
+    }).catch(() => void 0);
+  };
+  const emitCompleted = (span, details) => {
+    const spanId = span.spanContext().spanId;
+    const trackedSpan = queryStartTimes.get(spanId);
+    const startTimeNs = trackedSpan?.startTimeNs ?? Date.now() * 1e6;
+    const hookSpanId = trackedSpan?.hookSpanId ?? normalizeHexId(void 0, 16);
+    queryStartTimes.delete(spanId);
+    void emitDatabaseHookGovernance({
+      details,
+      hookSpanId,
+      hookGovernance,
+      span,
+      stage: "completed",
+      startTimeNs
+    }).catch(() => void 0);
+  };
+  if (moduleName === "@opentelemetry/instrumentation-pg") {
+    return {
+      enhancedDatabaseReporting: true,
+      requestHook(span, info) {
+        const dbStatement = info.query?.text ?? toStringValue(getSpanAttribute(span, "db.statement"));
+        emitStarted(span, {
+          dbName: info.connection?.database ?? toStringValue(getSpanAttribute(span, "db.name")),
+          dbOperation: parseDbOperation(dbStatement) ?? toStringValue(getSpanAttribute(span, "db.operation")),
+          dbStatement,
+          dbSystem: toStringValue(getSpanAttribute(span, "db.system")) ?? "postgresql",
+          serverAddress: info.connection?.host ?? toStringValue(getSpanAttribute(span, "server.address")) ?? toStringValue(getSpanAttribute(span, "net.peer.name")),
+          serverPort: toNumberValue(getSpanAttribute(span, "server.port")) ?? toNumberValue(getSpanAttribute(span, "net.peer.port")) ?? info.connection?.port
+        });
+      },
+      responseHook(span) {
+        const dbStatement = toStringValue(getSpanAttribute(span, "db.statement"));
+        emitCompleted(span, {
+          dbName: toStringValue(getSpanAttribute(span, "db.name")),
+          dbOperation: parseDbOperation(dbStatement) ?? toStringValue(getSpanAttribute(span, "db.operation")),
+          dbStatement,
+          dbSystem: toStringValue(getSpanAttribute(span, "db.system")) ?? "postgresql",
+          error: toStringValue(getSpanAttribute(span, "error.type")) ?? toStringValue(getSpanAttribute(span, "exception.message")),
+          serverAddress: toStringValue(getSpanAttribute(span, "server.address")) ?? toStringValue(getSpanAttribute(span, "net.peer.name")),
+          serverPort: toNumberValue(getSpanAttribute(span, "server.port")) ?? toNumberValue(getSpanAttribute(span, "net.peer.port"))
+        });
+      }
+    };
+  }
+  if (moduleName === "@opentelemetry/instrumentation-oracledb") {
+    return {
+      enhancedDatabaseReporting: true,
+      requestHook(span, info) {
+        const dbStatement = Array.isArray(info.inputArgs) ? toStringValue(info.inputArgs[0]) : void 0;
+        emitStarted(span, {
+          dbName: info.connection?.serviceName ?? toStringValue(getSpanAttribute(span, "db.name")),
+          dbOperation: parseDbOperation(dbStatement) ?? toStringValue(getSpanAttribute(span, "db.operation")),
+          dbStatement: dbStatement ?? toStringValue(getSpanAttribute(span, "db.statement")),
+          dbSystem: toStringValue(getSpanAttribute(span, "db.system")) ?? "oracle",
+          serverAddress: info.connection?.hostName ?? toStringValue(getSpanAttribute(span, "server.address")) ?? toStringValue(getSpanAttribute(span, "net.peer.name")),
+          serverPort: toNumberValue(getSpanAttribute(span, "server.port")) ?? toNumberValue(getSpanAttribute(span, "net.peer.port")) ?? info.connection?.port
+        });
+      },
+      responseHook(span) {
+        const dbStatement = toStringValue(getSpanAttribute(span, "db.statement"));
+        emitCompleted(span, {
+          dbName: toStringValue(getSpanAttribute(span, "db.name")),
+          dbOperation: parseDbOperation(dbStatement) ?? toStringValue(getSpanAttribute(span, "db.operation")),
+          dbStatement,
+          dbSystem: toStringValue(getSpanAttribute(span, "db.system")) ?? "oracle",
+          error: toStringValue(getSpanAttribute(span, "error.type")) ?? toStringValue(getSpanAttribute(span, "exception.message")),
+          serverAddress: toStringValue(getSpanAttribute(span, "server.address")) ?? toStringValue(getSpanAttribute(span, "net.peer.name")),
+          serverPort: toNumberValue(getSpanAttribute(span, "server.port")) ?? toNumberValue(getSpanAttribute(span, "net.peer.port"))
+        });
+      }
+    };
+  }
+  return void 0;
+}
+async function emitDatabaseHookGovernance(input) {
+  const spanContext = input.span.spanContext();
+  const nowNs = Date.now() * 1e6;
+  const dbOperation = input.details.dbOperation ?? "query";
+  const hookTrigger = {
+    attribute_key_identifiers: ["db.system", "db.operation", "db.statement"],
+    db_name: input.details.dbName,
+    db_operation: dbOperation,
+    db_statement: input.details.dbStatement,
+    db_system: input.details.dbSystem ?? "unknown",
+    server_address: input.details.serverAddress,
+    server_port: input.details.serverPort,
+    stage: input.stage,
+    type: "db_query"
+  };
+  if (input.stage === "completed") {
+    hookTrigger.duration_ms = Math.max(
+      0,
+      Math.round((nowNs - input.startTimeNs) / 1e6)
+    );
+    hookTrigger.error = input.details.error;
+  }
+  await evaluateHookGovernance(input.hookGovernance, {
+    activeSpan: input.span,
+    hookTrigger,
+    span: createHookSpan({
+      attributes: {
+        "db.name": input.details.dbName ?? "unknown",
+        "db.operation": dbOperation,
+        "db.statement": input.details.dbStatement ?? "",
+        "db.system": input.details.dbSystem ?? "unknown",
+        ...input.details.serverAddress ? { "server.address": input.details.serverAddress } : {},
+        ...typeof input.details.serverPort === "number" ? { "server.port": input.details.serverPort } : {}
+      },
+      dbName: input.details.dbName,
+      dbOperation,
+      dbStatement: input.details.dbStatement,
+      dbSystem: input.details.dbSystem ?? "unknown",
+      endTimeNs: nowNs,
+      error: input.details.error,
+      hookType: "db_query",
+      kind: "CLIENT",
+      name: input.span.name ?? `DB ${dbOperation}`,
+      parentSpanId: spanContext.spanId,
+      semanticType: resolveDatabaseSemanticType(dbOperation),
+      serverAddress: input.details.serverAddress,
+      serverPort: input.details.serverPort,
+      spanId: input.hookSpanId,
+      stage: input.stage,
+      startTimeNs: input.startTimeNs,
+      traceId: spanContext.traceId
+    }),
+    stage: input.stage,
+    traceId: spanContext.traceId
+  });
+}
+function patchFetch(spanProcessor, ignoredUrls, hookGovernance) {
+  const originalFetch = globalThis.fetch;
+  if (!originalFetch || !globalThis.Request || !globalThis.Response || !globalThis.Headers) {
+    throw new Error("Global fetch APIs are required for OpenBox HTTP body capture");
+  }
+  globalThis.fetch = async function patchedFetch(input, init) {
+    const request = new globalThis.Request(input, init);
+    const url = request.url;
+    if (shouldIgnoreUrl(url, ignoredUrls)) {
+      return originalFetch(request);
+    }
+    const activeSpan = trace.getActiveSpan();
+    if (!activeSpan) {
+      return originalFetch(request);
+    }
+    const requestBody = normalizeHookBodyForTelemetry(
+      await captureRequestBody(request)
+    );
+    const requestHeaders = headersToRecord(request.headers);
+    const spanContext = activeSpan.spanContext();
+    const startTimeNs = Date.now() * 1e6;
+    const hookSpanId = normalizeHexId(void 0, 16);
+    const startedSemanticType = resolveHttpSemanticType({
+      method: request.method,
+      requestBody,
+      url
+    });
+    await evaluateHookGovernance(hookGovernance, {
+      activeSpan,
+      hookTrigger: {
+        method: request.method,
+        request_body: requestBody,
+        request_headers: requestHeaders,
+        stage: "started",
+        type: "http_request",
+        url
+      },
+      span: createHookSpan({
+        attributes: {
+          "http.method": request.method,
+          "http.url": url
+        },
+        endTimeNs: startTimeNs,
+        hookType: "http_request",
+        httpMethod: request.method,
+        httpUrl: url,
+        kind: "CLIENT",
+        name: `HTTP ${request.method}`,
+        parentSpanId: spanContext.spanId,
+        requestBody,
+        requestHeaders,
+        semanticType: startedSemanticType,
+        spanId: hookSpanId,
+        stage: "started",
+        startTimeNs,
+        traceId: spanContext.traceId
+      }),
+      stage: "started",
+      traceId: spanContext.traceId
+    });
+    const response = await originalFetch(request);
+    const responseHeaders = headersToRecord(response.headers);
+    const responseBody = normalizeHookBodyForTelemetry(
+      await captureResponseBody(response)
+    );
+    spanProcessor.storeTraceBody(spanContext.traceId, {
+      method: request.method,
+      requestBody,
+      requestHeaders,
+      responseBody,
+      responseHeaders,
+      url
+    });
+    const endTimeNs = Date.now() * 1e6;
+    const completedHookTrigger = {
+      method: request.method,
+      request_body: requestBody,
+      request_headers: requestHeaders,
+      response_body: responseBody,
+      response_headers: responseHeaders,
+      status_code: response.status,
+      type: "http_request",
+      url
+    };
+    const completedSemanticType = resolveHttpSemanticType({
+      method: request.method,
+      requestBody,
+      responseBody,
+      url
+    });
+    const completedHookSpanBase = {
+      attributes: {
+        "http.method": request.method,
+        "http.status_code": response.status,
+        "http.url": url
+      },
+      endTimeNs,
+      hookType: "http_request",
+      httpMethod: request.method,
+      httpStatusCode: response.status,
+      httpUrl: url,
+      kind: "CLIENT",
+      name: `HTTP ${request.method}`,
+      parentSpanId: spanContext.spanId,
+      requestBody,
+      requestHeaders,
+      responseBody,
+      responseHeaders,
+      semanticType: completedSemanticType,
+      spanId: hookSpanId,
+      startTimeNs,
+      traceId: spanContext.traceId
+    };
+    await evaluateHookGovernance(hookGovernance, {
+      activeSpan,
+      hookTrigger: {
+        ...completedHookTrigger,
+        stage: "completed"
+      },
+      span: createHookSpan({
+        ...completedHookSpanBase,
+        stage: "completed"
+      }),
+      stage: "completed",
+      traceId: spanContext.traceId
+    });
+    return response;
+  };
+  return () => {
+    globalThis.fetch = originalFetch;
+  };
+}
+async function captureRequestBody(request) {
+  const contentType = request.headers.get("content-type");
+  if (!isTextContentType(contentType)) {
+    return void 0;
+  }
+  const clone = request.clone();
+  const text = await clone.text();
+  return text || void 0;
+}
+async function captureResponseBody(response) {
+  const contentType = response.headers.get("content-type");
+  if (!isTextContentType(contentType)) {
+    return void 0;
+  }
+  const clone = response.clone();
+  const text = await clone.text();
+  return text || void 0;
+}
+function headersToRecord(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function shouldIgnoreUrl(url, ignoredUrls) {
+  if (!url) {
+    return false;
+  }
+  return ignoredUrls.some((prefix) => url.startsWith(prefix));
+}
+function resolveHttpSemanticType(input) {
+  const normalizedMethod = input.method.trim().toUpperCase();
+  const requestRecords = parseHookBodyRecords(input.requestBody);
+  const responseRecords = parseHookBodyRecords(input.responseBody);
+  const modelId = extractModelFromRecords(responseRecords) ?? extractModelFromRecords(requestRecords);
+  const provider = inferProviderFromUrl(input.url) ?? inferProviderFromModelId(modelId);
+  if (normalizedMethod === "POST" && provider) {
+    return isLikelyLlmEmbedding(input.url, requestRecords, responseRecords) ? "llm_embedding" : "llm_completion";
+  }
+  switch (normalizedMethod) {
+    case "GET":
+      return "http_get";
+    case "POST":
+      return "http_post";
+    case "PUT":
+      return "http_put";
+    case "PATCH":
+      return "http_patch";
+    case "DELETE":
+      return "http_delete";
+    default:
+      return "http";
+  }
+}
+function resolveDatabaseSemanticType(operation) {
+  const normalized = operation.trim().toUpperCase();
+  switch (normalized) {
+    case "SELECT":
+      return "database_select";
+    case "INSERT":
+      return "database_insert";
+    case "UPDATE":
+      return "database_update";
+    case "DELETE":
+      return "database_delete";
+    default:
+      return "database_query";
+  }
+}
+function isLikelyLlmEmbedding(url, requestRecords, responseRecords) {
+  const normalizedUrl = url.toLowerCase();
+  if (normalizedUrl.includes("embedding")) {
+    return true;
+  }
+  const combined = JSON.stringify([...requestRecords, ...responseRecords]).toLowerCase();
+  return combined.includes("embedding");
+}
+function isTextContentType(contentType) {
+  if (!contentType) {
+    return true;
+  }
+  const normalized = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
+  return TEXT_CONTENT_TYPES.some((type) => normalized.startsWith(type));
+}
+function buildRequestUrl(request) {
+  if (request.href) {
+    return request.href;
+  }
+  if (!request.protocol || !(request.host || request.hostname)) {
+    return void 0;
+  }
+  const host = request.host ?? request.hostname;
+  return `${request.protocol}//${host}${request.path ?? ""}`;
+}
+function getFilePathFromArgs(args) {
+  const candidate = args[0];
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function teardownActiveTelemetry() {
+  activeFetchRestore?.();
+  activeFetchRestore = void 0;
+  activeFileRestore?.();
+  activeFileRestore = void 0;
+  activeHookGovernanceRuntime = void 0;
+  activeUnregister?.();
+  activeUnregister = void 0;
+}
+function disableGlobalTraceApi() {
+  const traceApi = trace;
+  traceApi.disable?.();
+}
+function patchFileIo(fileSkipPatterns, hookGovernance) {
+  const require2 = createRequire(import.meta.url);
+  const fsPromises = require2("node:fs/promises");
+  const fsModule = require2("node:fs");
+  const tracer = trace.getTracer("openbox.file-io");
+  const originalReadFile = fsPromises.readFile;
+  const originalWriteFile = fsPromises.writeFile;
+  const originalFsReadFile = fsModule.promises.readFile;
+  const originalFsWriteFile = fsModule.promises.writeFile;
+  const tracedReadFile = async function openBoxReadFile(...args) {
+    const [path] = args;
+    const filePath = String(path);
+    if (shouldSkipFilePath(filePath, fileSkipPatterns)) {
+      return originalReadFile(...args);
+    }
+    return context.with(context.active(), async () => {
+      return tracer.startActiveSpan("file.read", async (span) => {
+        span.setAttribute("file.path", filePath);
+        span.setAttribute("file.operation", "read");
+        const spanContext = span.spanContext();
+        const startTimeNs = Date.now() * 1e6;
+        const hookSpanId = normalizeHexId(void 0, 16);
+        await evaluateHookGovernance(hookGovernance, {
+          activeSpan: span,
+          hookTrigger: {
+            attribute_key_identifiers: ["file.path", "file.operation"],
+            file_operation: "read",
+            file_path: filePath,
+            stage: "started",
+            type: "file_operation"
+          },
+          span: createHookSpan({
+            attributes: {
+              "file.operation": "read",
+              "file.path": filePath
+            },
+            endTimeNs: startTimeNs,
+            fileMode: "r",
+            fileOperation: "read",
+            filePath,
+            hookType: "file_operation",
+            kind: "INTERNAL",
+            name: "file.read",
+            parentSpanId: spanContext.spanId,
+            semanticType: "file_read",
+            spanId: hookSpanId,
+            stage: "started",
+            startTimeNs,
+            traceId: spanContext.traceId
+          }),
+          stage: "started",
+          traceId: spanContext.traceId
+        });
+        try {
+          const result = await originalReadFile(...args);
+          const bytes = getByteLength(result);
+          const endTimeNs = Date.now() * 1e6;
+          span.setAttribute("file.bytes", bytes);
+          await evaluateHookGovernance(hookGovernance, {
+            activeSpan: span,
+            hookTrigger: {
+              attribute_key_identifiers: ["file.path", "file.operation"],
+              bytes_read: bytes,
+              file_operation: "read",
+              file_path: filePath,
+              stage: "completed",
+              type: "file_operation"
+            },
+            span: createHookSpan({
+              attributes: {
+                "file.bytes": bytes,
+                "file.operation": "read",
+                "file.path": filePath
+              },
+              bytesRead: bytes,
+              endTimeNs,
+              fileMode: "r",
+              fileOperation: "read",
+              filePath,
+              hookType: "file_operation",
+              kind: "INTERNAL",
+              name: "file.read",
+              parentSpanId: spanContext.spanId,
+              semanticType: "file_read",
+              spanId: hookSpanId,
+              stage: "completed",
+              startTimeNs,
+              traceId: spanContext.traceId
+            }),
+            stage: "completed",
+            traceId: spanContext.traceId
+          });
+          return result;
+        } finally {
+          span.end();
+        }
+      });
+    });
+  };
+  const tracedWriteFile = async function openBoxWriteFile(...args) {
+    const [file, data] = args;
+    const filePath = String(file);
+    if (shouldSkipFilePath(filePath, fileSkipPatterns)) {
+      return originalWriteFile(...args);
+    }
+    return context.with(context.active(), async () => {
+      return tracer.startActiveSpan("file.write", async (span) => {
+        span.setAttribute("file.path", filePath);
+        span.setAttribute("file.operation", "write");
+        const bytes = getByteLength(data);
+        const spanContext = span.spanContext();
+        const startTimeNs = Date.now() * 1e6;
+        const hookSpanId = normalizeHexId(void 0, 16);
+        span.setAttribute("file.bytes", bytes);
+        await evaluateHookGovernance(hookGovernance, {
+          activeSpan: span,
+          hookTrigger: {
+            attribute_key_identifiers: ["file.path", "file.operation"],
+            bytes_written: bytes,
+            file_operation: "write",
+            file_path: filePath,
+            stage: "started",
+            type: "file_operation"
+          },
+          span: createHookSpan({
+            attributes: {
+              "file.bytes": bytes,
+              "file.operation": "write",
+              "file.path": filePath
+            },
+            bytesWritten: bytes,
+            endTimeNs: startTimeNs,
+            fileMode: "w",
+            fileOperation: "write",
+            filePath,
+            hookType: "file_operation",
+            kind: "INTERNAL",
+            name: "file.write",
+            parentSpanId: spanContext.spanId,
+            semanticType: "file_write",
+            spanId: hookSpanId,
+            stage: "started",
+            startTimeNs,
+            traceId: spanContext.traceId
+          }),
+          stage: "started",
+          traceId: spanContext.traceId
+        });
+        try {
+          const result = await originalWriteFile(...args);
+          const endTimeNs = Date.now() * 1e6;
+          await evaluateHookGovernance(hookGovernance, {
+            activeSpan: span,
+            hookTrigger: {
+              attribute_key_identifiers: ["file.path", "file.operation"],
+              bytes_written: bytes,
+              file_operation: "write",
+              file_path: filePath,
+              stage: "completed",
+              type: "file_operation"
+            },
+            span: createHookSpan({
+              attributes: {
+                "file.bytes": bytes,
+                "file.operation": "write",
+                "file.path": filePath
+              },
+              bytesWritten: bytes,
+              endTimeNs,
+              fileMode: "w",
+              fileOperation: "write",
+              filePath,
+              hookType: "file_operation",
+              kind: "INTERNAL",
+              name: "file.write",
+              parentSpanId: spanContext.spanId,
+              semanticType: "file_write",
+              spanId: hookSpanId,
+              stage: "completed",
+              startTimeNs,
+              traceId: spanContext.traceId
+            }),
+            stage: "completed",
+            traceId: spanContext.traceId
+          });
+          return result;
+        } finally {
+          span.end();
+        }
+      });
+    });
+  };
+  fsPromises.readFile = tracedReadFile;
+  fsPromises.writeFile = tracedWriteFile;
+  fsModule.promises.readFile = tracedReadFile;
+  fsModule.promises.writeFile = tracedWriteFile;
+  syncBuiltinESMExports();
+  return () => {
+    fsPromises.readFile = originalReadFile;
+    fsPromises.writeFile = originalWriteFile;
+    fsModule.promises.readFile = originalFsReadFile;
+    fsModule.promises.writeFile = originalFsWriteFile;
+    syncBuiltinESMExports();
+  };
+}
+function getByteLength(value) {
+  if (typeof value === "string") {
+    return Buffer.byteLength(value);
+  }
+  if (value instanceof Uint8Array) {
+    return value.byteLength;
+  }
+  return 0;
+}
+function shouldSkipFilePath(filePath, fileSkipPatterns) {
+  return fileSkipPatterns.some((pattern) => filePath.includes(pattern));
+}
+async function evaluateHookGovernance(hookGovernance, input) {
+  if (!hookGovernance) {
+    return;
+  }
+  const activityContext = resolveActivityContext(
+    hookGovernance.spanProcessor,
+    input.traceId
+  );
+  if (!activityContext) {
+    return;
+  }
+  const hookSpan = enrichHookSpanForData(
+    cloneHookSpanPayload(input.span)
+  );
+  const hookSpanForPayload = input.stage === "started" ? ensureStartedHookSpan(hookSpan) : ensureCompletedHookSpan(hookSpan);
+  if (activityContext.syntheticAgentActivity) {
+    hookGovernance.spanProcessor.appendAgentSignalHookSpan(
+      activityContext.workflowId,
+      activityContext.runId,
+      hookSpanForPayload
+    );
+    return;
+  }
+  const priorAbortReason = hookGovernance.spanProcessor.getActivityAbort(
+    activityContext.workflowId,
+    activityContext.activityId
+  );
+  if (priorAbortReason) {
+    if (priorAbortReason.startsWith(APPROVAL_ABORT_PREFIX)) {
+      throw new ApprovalPendingError(
+        priorAbortReason.slice(APPROVAL_ABORT_PREFIX.length)
+      );
+    }
+    throw new GovernanceHaltError(`Governance blocked: ${priorAbortReason}`);
+  }
+  const parentActivityApproved = isActivityApproved(
+    activityContext.runId,
+    activityContext.activityId
+  );
+  const pendingApproval = getPendingApproval(activityContext.runId);
+  if (pendingApproval?.activityId === activityContext.activityId) {
+    return;
+  }
+  hookGovernance.spanProcessor.markGoverned(
+    input.activeSpan.spanContext().spanId
+  );
+  const modelUsage = extractModelUsageFromHookSpan(hookSpan);
+  const telemetryModelId = toTelemetryModelId(modelUsage.modelId);
+  const hookType = toStringValue(hookSpan.hook_type) ?? toStringValue(input.hookTrigger.type) ?? "hook";
+  const hookActivityType = resolveHookActivityType(
+    activityContext.activityType,
+    hookType
+  );
+  const eventType = WorkflowEventType.ACTIVITY_STARTED;
+  const payload = {
+    activity_id: activityContext.activityId,
+    attempt: typeof activityContext.attempt === "number" ? activityContext.attempt : 1,
+    activity_type: hookActivityType,
+    event_type: eventType,
+    hook_trigger: true,
+    ...activityContext.goal ? { goal: activityContext.goal } : {},
+    run_id: activityContext.runId,
+    source: "workflow-telemetry",
+    ...modelUsage.modelId ? { model_id: modelUsage.modelId } : {},
+    ...telemetryModelId ? { model: telemetryModelId } : {},
+    ...modelUsage.provider ? { model_provider: modelUsage.provider } : {},
+    ...modelUsage.provider ? { provider: modelUsage.provider } : {},
+    ...typeof modelUsage.inputTokens === "number" ? { input_tokens: modelUsage.inputTokens } : {},
+    ...typeof modelUsage.outputTokens === "number" ? { output_tokens: modelUsage.outputTokens } : {},
+    ...typeof modelUsage.totalTokens === "number" ? { total_tokens: modelUsage.totalTokens } : {},
+    span_count: 1,
+    spans: [hookSpanForPayload],
+    task_queue: activityContext.taskQueue,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    workflow_id: activityContext.workflowId,
+    workflow_type: activityContext.workflowType
+  };
+  if (activityContext.activityInput !== void 0) {
+    payload.activity_input = activityContext.activityInput;
+  }
+  if (activityContext.activityType === "agentLlmCompletion") {
+    const derivedActivityPayload = deriveAgentHookActivityPayload(
+      input.hookTrigger,
+      input.stage
+    );
+    if (payload.activity_input === void 0 && derivedActivityPayload.activityInput !== void 0) {
+      payload.activity_input = derivedActivityPayload.activityInput;
+    }
+    if (derivedActivityPayload.activityOutput !== void 0) {
+      payload.activity_output = derivedActivityPayload.activityOutput;
+    }
+  }
+  if (activityContext.goal) {
+    payload.activity_input = appendGoalToHookActivityInput(
+      payload.activity_input,
+      activityContext.goal
+    );
+  }
+  let verdict;
+  try {
+    verdict = await hookGovernance.client.evaluate(payload);
+  } catch (error) {
+    if (hookGovernance.onApiError === "fail_open") {
+      return;
+    }
+    throw new GovernanceHaltError(
+      `Governance API error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!verdict || !Verdict.shouldStop(verdict.verdict) && !Verdict.requiresApproval(verdict.verdict)) {
+    return;
+  }
+  if (parentActivityApproved) {
+    return;
+  }
+  const reason = verdict.reason ?? "Hook blocked by governance";
+  const abortReason = Verdict.requiresApproval(verdict.verdict) ? `${APPROVAL_ABORT_PREFIX}${reason}` : reason;
+  hookGovernance.spanProcessor.setActivityAbort(
+    activityContext.workflowId,
+    activityContext.activityId,
+    abortReason
+  );
+  if (Verdict.requiresApproval(verdict.verdict)) {
+    throw new ApprovalPendingError(reason);
+  }
+  if (verdict.verdict === Verdict.HALT) {
+    hookGovernance.spanProcessor.setHaltRequested(
+      activityContext.workflowId,
+      activityContext.activityId,
+      reason
+    );
+  }
+  throw new GovernanceHaltError(`Governance blocked: ${reason}`);
+}
+function resolveHookActivityType(parentActivityType, hookType) {
+  if (typeof parentActivityType === "string" && parentActivityType.toLowerCase() === "agentllmcompletion") {
+    return parentActivityType;
+  }
+  return hookType;
+}
+function cloneHookSpanPayload(span) {
+  try {
+    return structuredClone(span);
+  } catch {
+    return { ...span };
+  }
+}
+function ensureStartedHookSpan(span) {
+  const startedSpan = cloneHookSpanPayload(span);
+  startedSpan.stage = "started";
+  delete startedSpan.end_time;
+  delete startedSpan.duration_ns;
+  delete startedSpan.response_body;
+  delete startedSpan.response_headers;
+  delete startedSpan.http_status_code;
+  delete startedSpan.rowcount;
+  delete startedSpan.data;
+  delete startedSpan.bytes_read;
+  delete startedSpan.bytes_written;
+  delete startedSpan.lines_count;
+  delete startedSpan.result;
+  delete startedSpan.error;
+  return enrichHookSpanForData(startedSpan);
+}
+function ensureCompletedHookSpan(span) {
+  const completedSpan = cloneHookSpanPayload(span);
+  completedSpan.stage = "completed";
+  return enrichHookSpanForData(completedSpan);
+}
+function enrichHookSpanForData(span) {
+  if (span.data !== void 0) {
+    return span;
+  }
+  const hookType = toStringValue(span.hook_type);
+  if (!hookType) {
+    return span;
+  }
+  if (hookType === "http_request") {
+    const data = {};
+    const method = toStringValue(span.http_method);
+    const url = toStringValue(span.http_url);
+    const requestBody = toStringValue(span.request_body);
+    const responseBody = toStringValue(span.response_body);
+    const statusCode = toNumberValue(span.http_status_code);
+    if (method) {
+      data.method = method;
+    }
+    if (url) {
+      data.url = url;
+    }
+    if (requestBody !== void 0) {
+      data.request_body = requestBody;
+    }
+    if (responseBody !== void 0) {
+      data.response_body = responseBody;
+    }
+    if (statusCode !== void 0) {
+      data.status_code = statusCode;
+    }
+    if (Object.keys(data).length > 0) {
+      span.data = data;
+    }
+    return span;
+  }
+  if (hookType === "db_query") {
+    const data = {};
+    const dbSystem = toStringValue(span.db_system);
+    const dbName = toStringValue(span.db_name);
+    const dbOperation = toStringValue(span.db_operation);
+    const dbStatement = toStringValue(span.db_statement);
+    const rowcount = toNumberValue(span.rowcount);
+    const serverAddress = toStringValue(span.server_address);
+    const serverPort = toNumberValue(span.server_port);
+    if (dbSystem) {
+      data.db_system = dbSystem;
+    }
+    if (dbName) {
+      data.db_name = dbName;
+    }
+    if (dbOperation) {
+      data.db_operation = dbOperation;
+    }
+    if (dbStatement) {
+      data.db_statement = dbStatement;
+    }
+    if (rowcount !== void 0) {
+      data.rowcount = rowcount;
+    }
+    if (serverAddress) {
+      data.server_address = serverAddress;
+    }
+    if (serverPort !== void 0) {
+      data.server_port = serverPort;
+    }
+    if (Object.keys(data).length > 0) {
+      span.data = data;
+    }
+    return span;
+  }
+  if (hookType === "function_call") {
+    const data = {};
+    const functionName = toStringValue(span.function);
+    const module = toStringValue(span.module);
+    if (functionName) {
+      data.function = functionName;
+    }
+    if (module) {
+      data.module = module;
+    }
+    if (span.args !== void 0) {
+      data.args = span.args;
+    }
+    if (span.result !== void 0) {
+      data.result = span.result;
+    }
+    if (Object.keys(data).length > 0) {
+      span.data = data;
+    }
+    return span;
+  }
+  if (hookType === "file_operation") {
+    const data = {};
+    const filePath = toStringValue(span.file_path);
+    const fileMode = toStringValue(span.file_mode);
+    const fileOperation = toStringValue(span.file_operation);
+    const bytesRead = toNumberValue(span.bytes_read);
+    const bytesWritten = toNumberValue(span.bytes_written);
+    const linesCount = toNumberValue(span.lines_count);
+    if (filePath) {
+      data.file_path = filePath;
+    }
+    if (fileMode) {
+      data.file_mode = fileMode;
+    }
+    if (fileOperation) {
+      data.file_operation = fileOperation;
+    }
+    if (bytesRead !== void 0) {
+      data.bytes_read = bytesRead;
+    }
+    if (bytesWritten !== void 0) {
+      data.bytes_written = bytesWritten;
+    }
+    if (linesCount !== void 0) {
+      data.lines_count = linesCount;
+    }
+    if (Object.keys(data).length > 0) {
+      span.data = data;
+    }
+  }
+  return span;
+}
+function extractModelUsageFromHookSpan(span) {
+  const requestBody = toStringValue(span.request_body ?? span.requestBody);
+  const responseBody = toStringValue(span.response_body ?? span.responseBody);
+  const requestRecords = parseHookBodyRecords(requestBody);
+  const responseRecords = parseHookBodyRecords(responseBody);
+  const modelFromResponse = extractModelFromRecords(responseRecords);
+  const modelFromRequest = extractModelFromRecords(requestRecords);
+  const modelId = modelFromResponse ?? modelFromRequest;
+  const usageFromResponse = extractUsageFromRecords(responseRecords);
+  const attributes = span.attributes && typeof span.attributes === "object" ? span.attributes : void 0;
+  const providerFromRecords = extractProviderFromRecords(responseRecords) ?? extractProviderFromRecords(requestRecords);
+  const providerFromUrl = inferProviderFromUrl(
+    toStringValue(attributes?.["http.url"] ?? attributes?.["url.full"])
+  );
+  const providerFromModel = inferProviderFromModelId(modelId);
+  const provider = providerFromRecords ?? providerFromUrl ?? providerFromModel;
+  return {
+    ...modelId ? { modelId } : {},
+    ...provider ? { provider } : {},
+    ...usageFromResponse?.inputTokens !== void 0 ? { inputTokens: usageFromResponse.inputTokens } : {},
+    ...usageFromResponse?.outputTokens !== void 0 ? { outputTokens: usageFromResponse.outputTokens } : {},
+    ...usageFromResponse?.totalTokens !== void 0 ? { totalTokens: usageFromResponse.totalTokens } : {}
+  };
+}
+function parseHookBodyRecords(body) {
+  if (!body) {
+    return [];
+  }
+  const serializedRecords = /* @__PURE__ */ new Set();
+  const records = [];
+  const pushRecord = (record) => {
+    if (!record) {
+      return;
+    }
+    const serialized = JSON.stringify(record);
+    if (serializedRecords.has(serialized)) {
+      return;
+    }
+    serializedRecords.add(serialized);
+    records.push(record);
+  };
+  const direct = parseJsonRecord(body);
+  pushRecord(direct);
+  for (const eventBody of parseSseDataBodies(body)) {
+    pushRecord(parseJsonRecord(eventBody));
+  }
+  for (const eventBody of parseInlineSseDataBodies(body)) {
+    pushRecord(parseJsonRecord(eventBody));
+  }
+  return records;
+}
+function deriveAgentHookActivityPayload(hookTrigger, stage) {
+  const hookType = toStringValue(hookTrigger.type);
+  if (hookType === "http_request") {
+    const requestRecords = parseHookBodyRecords(
+      toStringValue(hookTrigger.request_body)
+    );
+    const responseRecords = parseHookBodyRecords(
+      toStringValue(hookTrigger.response_body)
+    );
+    const activityInput = normalizeActivityInputList(
+      compactHookPayloadValue(
+        deriveAgentRequestSummaryFromRecords(requestRecords) ?? parseHookPayloadBodyValue(hookTrigger.request_body)
+      )
+    );
+    const activityOutput = stage === "completed" ? compactHookPayloadValue(
+      deriveAgentResponseSummaryFromRecords(responseRecords) ?? parseHookPayloadBodyValue(hookTrigger.response_body)
+    ) : void 0;
+    return {
+      ...activityInput !== void 0 ? { activityInput } : {},
+      ...activityOutput !== void 0 ? { activityOutput } : {}
+    };
+  }
+  if (hookType === "function_call") {
+    const activityInput = normalizeActivityInputList(
+      compactHookPayloadValue(sanitizeForGovernancePayload(hookTrigger.args))
+    );
+    const activityOutput = stage === "completed" ? compactHookPayloadValue(
+      sanitizeForGovernancePayload(hookTrigger.result)
+    ) : void 0;
+    return {
+      ...activityInput !== void 0 ? { activityInput } : {},
+      ...activityOutput !== void 0 ? { activityOutput } : {}
+    };
+  }
+  return {};
+}
+function parseHookPayloadBodyValue(body) {
+  if (body === void 0 || body === null) {
+    return void 0;
+  }
+  if (typeof body !== "string") {
+    return sanitizeForGovernancePayload(body);
+  }
+  const trimmed = body.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    return sanitizeForGovernancePayload(JSON.parse(trimmed));
+  } catch {
+    return trimmed;
+  }
+}
+function compactHookPayloadValue(value, maxBytes = 16384) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 8e3 ? `${trimmed.slice(0, 7984)}...[truncated]` : trimmed;
+  }
+  const serialized = JSON.stringify(value);
+  const sizeBytes = Buffer.byteLength(serialized, "utf8");
+  if (sizeBytes <= maxBytes) {
+    return value;
+  }
+  return {
+    preview: `${serialized.slice(0, 3984)}...[truncated]`,
+    truncated: true
+  };
+}
+function normalizeActivityInputList(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+function appendGoalToHookActivityInput(activityInput, goal) {
+  const trimmedGoal = goal.trim();
+  if (trimmedGoal.length === 0) {
+    if (Array.isArray(activityInput)) {
+      return activityInput;
+    }
+    if (activityInput === void 0 || activityInput === null) {
+      return [];
+    }
+    return [activityInput];
+  }
+  if (Array.isArray(activityInput)) {
+    const inputItems = activityInput;
+    if (inputItems.length === 0) {
+      return [{ goal: trimmedGoal }];
+    }
+    const [first, ...rest] = inputItems;
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+      const firstRecord = first;
+      const existingGoal = firstRecord.goal;
+      if (typeof existingGoal === "string" && existingGoal.trim().length > 0) {
+        return inputItems;
+      }
+      return [{ ...firstRecord, goal: trimmedGoal }, ...rest];
+    }
+    return [...inputItems, { goal: trimmedGoal }];
+  }
+  if (activityInput === void 0 || activityInput === null) {
+    return [{ goal: trimmedGoal }];
+  }
+  if (activityInput && typeof activityInput === "object" && !Array.isArray(activityInput)) {
+    const activityRecord = activityInput;
+    const existingGoal = activityRecord.goal;
+    if (typeof existingGoal === "string" && existingGoal.trim().length > 0) {
+      return [activityRecord];
+    }
+    return [{ ...activityRecord, goal: trimmedGoal }];
+  }
+  return [activityInput, { goal: trimmedGoal }];
+}
+function parseInlineSseDataBodies(body) {
+  const payloads = [];
+  let searchIndex = 0;
+  while (searchIndex < body.length) {
+    const dataIndex = body.indexOf("data:", searchIndex);
+    if (dataIndex < 0) {
+      break;
+    }
+    const jsonStart = body.indexOf("{", dataIndex + 5);
+    if (jsonStart < 0) {
+      searchIndex = dataIndex + 5;
+      continue;
+    }
+    const jsonEnd = findJsonObjectEnd(body, jsonStart);
+    if (jsonEnd < 0) {
+      searchIndex = dataIndex + 5;
+      continue;
+    }
+    payloads.push(body.slice(jsonStart, jsonEnd + 1));
+    searchIndex = jsonEnd + 1;
+  }
+  return payloads;
+}
+function findJsonObjectEnd(source, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = startIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (!char) {
+      continue;
+    }
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function deriveAgentRequestSummaryFromRecords(records) {
+  const modelId = extractModelFromRecords(records);
+  const telemetryModelId = modelId ? toTelemetryModelId(modelId) : void 0;
+  const prompt = extractLatestUserPromptFromRecords(records);
+  const toolCount = extractToolCountFromRecords(records);
+  const summary = {
+    ...telemetryModelId ? { model: telemetryModelId } : {},
+    ...modelId && modelId !== telemetryModelId ? { model_id: modelId } : {},
+    ...prompt ? { prompt } : {},
+    ...typeof toolCount === "number" ? { tools_count: toolCount } : {}
+  };
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function deriveAgentResponseSummaryFromRecords(records) {
+  const modelId = extractModelFromRecords(records);
+  const telemetryModelId = modelId ? toTelemetryModelId(modelId) : void 0;
+  const usage = extractUsageFromRecords(records);
+  const text = extractResponseTextFromRecords(records);
+  const toolNames = extractToolCallNamesFromRecords(records);
+  const summary = {
+    ...telemetryModelId ? { model: telemetryModelId } : {},
+    ...modelId && modelId !== telemetryModelId ? { model_id: modelId } : {},
+    ...text ? { text } : {},
+    ...usage ? {
+      usage: {
+        ...typeof usage.inputTokens === "number" ? { input_tokens: usage.inputTokens } : {},
+        ...typeof usage.outputTokens === "number" ? { output_tokens: usage.outputTokens } : {},
+        ...typeof usage.totalTokens === "number" ? { total_tokens: usage.totalTokens } : {}
+      }
+    } : {},
+    ...toolNames.length > 0 ? {
+      tool_calls: toolNames,
+      tool_call_count: toolNames.length
+    } : {}
+  };
+  if (summary.usage && Object.keys(summary.usage).length === 0) {
+    delete summary.usage;
+  }
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function extractLatestUserPromptFromRecords(records) {
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const record = records[index];
+    if (!record) {
+      continue;
+    }
+    const prompt = extractLatestUserPromptFromInput(record.input) ?? extractLatestUserPromptFromInput(record.messages) ?? extractLatestUserPromptFromInput(record.prompt);
+    if (prompt) {
+      return truncateText(prompt, 1e3);
+    }
+  }
+  return void 0;
+}
+function extractLatestUserPromptFromInput(value) {
+  const inputs = Array.isArray(value) ? value : value !== void 0 ? [value] : [];
+  for (let index = inputs.length - 1; index >= 0; index -= 1) {
+    const entry = inputs[index];
+    if (typeof entry === "string") {
+      const trimmed = entry.trim();
+      if (trimmed.length > 0) {
+        return trimmed;
+      }
+      continue;
+    }
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const record = entry;
+    const role = toStringValue(record.role)?.toLowerCase();
+    if (role && role !== "user") {
+      continue;
+    }
+    const text = extractTextFromStructuredValue(record.content) ?? extractTextFromStructuredValue(record.input_text) ?? extractTextFromStructuredValue(record.text);
+    if (text) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function extractTextFromStructuredValue(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        const extracted = extractTextFromStructuredValue(parsed);
+        if (extracted && extracted.trim().length > 0) {
+          return extracted.trim();
+        }
+      } catch {
+      }
+    }
+    return trimmed;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => extractTextFromStructuredValue(item)).filter((item) => Boolean(item && item.trim().length > 0));
+    if (parts.length === 0) {
+      return void 0;
+    }
+    const combined = parts.join("\n").trim();
+    return combined.length > 0 ? combined : void 0;
+  }
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  const type = toStringValue(record.type)?.toLowerCase();
+  const text = extractTextFromStructuredValue(record.text) ?? extractTextFromStructuredValue(record.input_text) ?? extractTextFromStructuredValue(record.output_text) ?? extractTextFromStructuredValue(record.content);
+  if (!text) {
+    return void 0;
+  }
+  if (!type || type.includes("text") || type === "message") {
+    return text;
+  }
+  return text;
+}
+function extractToolCountFromRecords(records) {
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const tools = records[index]?.tools;
+    if (Array.isArray(tools)) {
+      return tools.length;
+    }
+  }
+  return void 0;
+}
+function extractResponseTextFromRecords(records) {
+  let deltaText = "";
+  let doneText;
+  let completedText;
+  for (const record of records) {
+    const type = toStringValue(record.type);
+    if (type === "response.output_text.delta") {
+      const delta = toStringValue(record.delta);
+      if (delta) {
+        deltaText += delta;
+      }
+      continue;
+    }
+    if (type === "response.output_text.done") {
+      const done = toStringValue(record.text);
+      if (done) {
+        doneText = done;
+      }
+      continue;
+    }
+    if (type === "response.completed") {
+      const response = record.response && typeof record.response === "object" ? record.response : void 0;
+      const responseText = extractTextFromStructuredValue(response?.output_text) ?? extractTextFromStructuredValue(response?.output) ?? extractTextFromStructuredValue(response?.text);
+      if (responseText) {
+        completedText = responseText;
+      }
+    }
+  }
+  const resolved = completedText ?? doneText ?? (deltaText.trim().length > 0 ? deltaText : void 0);
+  return resolved ? truncateText(resolved, 2e3) : void 0;
+}
+function extractToolCallNamesFromRecords(records) {
+  const names = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const type = toStringValue(record.type);
+    if (type === "response.output_item.added") {
+      const item = record.item && typeof record.item === "object" ? record.item : void 0;
+      const itemType = toStringValue(item?.type);
+      const itemName = toStringValue(item?.name);
+      if (itemType === "function_call" && itemName) {
+        names.add(itemName);
+      }
+    }
+    if (type === "response.completed") {
+      const response = record.response && typeof record.response === "object" ? record.response : void 0;
+      const output = Array.isArray(response?.output) ? response.output : [];
+      for (const outputItem of output) {
+        if (!outputItem || typeof outputItem !== "object") {
+          continue;
+        }
+        const outputRecord = outputItem;
+        const itemType = toStringValue(outputRecord.type);
+        const itemName = toStringValue(outputRecord.name);
+        if (itemType === "function_call" && itemName) {
+          names.add(itemName);
+        }
+      }
+    }
+  }
+  return [...names].slice(0, 8);
+}
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxChars - 16))}...[truncated]`;
+}
+function normalizeHookBodyForTelemetry(body) {
+  if (!body) {
+    return body;
+  }
+  const record = parseJsonRecord(body);
+  if (!record) {
+    return body;
+  }
+  let changed = false;
+  if (normalizeModelIdentifierInRecord(record)) {
+    changed = true;
+  }
+  const nestedResponse = record.response && typeof record.response === "object" && !Array.isArray(record.response) ? record.response : void 0;
+  if (nestedResponse && normalizeModelIdentifierInRecord(nestedResponse)) {
+    changed = true;
+  }
+  if (!changed) {
+    return body;
+  }
+  return JSON.stringify(record);
+}
+function normalizeModelIdentifierInRecord(record) {
+  const modelValue = typeof record.model === "string" ? record.model.trim() : void 0;
+  if (!modelValue) {
+    return false;
+  }
+  const parsedModel = parseModelIdentifier(modelValue);
+  const rawModelId = parsedModel.modelId ?? modelValue;
+  const telemetryModelId = toTelemetryModelId(rawModelId) ?? rawModelId;
+  let changed = false;
+  if (record.model !== telemetryModelId) {
+    record.model = telemetryModelId;
+    changed = true;
+  }
+  if (rawModelId !== telemetryModelId && (typeof record.model_id !== "string" || record.model_id.trim().length === 0)) {
+    record.model_id = rawModelId;
+    changed = true;
+  }
+  if (parsedModel.provider) {
+    if (typeof record.model_provider !== "string" || record.model_provider.trim().length === 0) {
+      record.model_provider = parsedModel.provider;
+      changed = true;
+    }
+    if (typeof record.provider !== "string" || record.provider.trim().length === 0) {
+      record.provider = parsedModel.provider;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function parseJsonRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function parseSseDataBodies(body) {
+  const lines = body.split(/\r?\n/);
+  const payloads = [];
+  let currentDataLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      if (currentDataLines.length > 0) {
+        payloads.push(currentDataLines.join("\n"));
+        currentDataLines = [];
+      }
+      continue;
+    }
+    if (!trimmed.startsWith("data:")) {
+      continue;
+    }
+    const data = trimmed.slice(5).trimStart();
+    if (data.length > 0) {
+      currentDataLines.push(data);
+    }
+  }
+  if (currentDataLines.length > 0) {
+    payloads.push(currentDataLines.join("\n"));
+  }
+  return payloads.filter((payload) => payload !== "[DONE]");
+}
+function extractModelFromRecords(records) {
+  for (const record of records) {
+    const nestedResponse = record.response && typeof record.response === "object" ? record.response : void 0;
+    const candidates = [
+      record.model_id,
+      nestedResponse?.model_id,
+      record.model,
+      nestedResponse?.model
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate !== "string" || candidate.trim().length === 0) {
+        continue;
+      }
+      const parsed = parseModelIdentifier(candidate);
+      if (parsed.modelId) {
+        return parsed.modelId;
+      }
+    }
+  }
+  return void 0;
+}
+function extractProviderFromRecords(records) {
+  for (const record of records) {
+    const nestedResponse = record.response && typeof record.response === "object" ? record.response : void 0;
+    const candidates = [
+      record.provider,
+      record.model_provider,
+      nestedResponse?.provider,
+      nestedResponse?.model_provider,
+      record.model,
+      nestedResponse?.model
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate !== "string" || candidate.trim().length === 0) {
+        continue;
+      }
+      const parsed = parseModelIdentifier(candidate);
+      if (parsed.provider) {
+        return parsed.provider;
+      }
+      const normalized = normalizeProvider(candidate);
+      if (normalized) {
+        return normalized;
+      }
+    }
+  }
+  return void 0;
+}
+function extractUsageFromRecords(records) {
+  let inputTokens;
+  let outputTokens;
+  let totalTokens;
+  for (const record of records) {
+    const usage = extractUsageFromRecord(record);
+    if (!usage) {
+      continue;
+    }
+    if (inputTokens === void 0 && usage.inputTokens !== void 0) {
+      inputTokens = usage.inputTokens;
+    }
+    if (outputTokens === void 0 && usage.outputTokens !== void 0) {
+      outputTokens = usage.outputTokens;
+    }
+    if (totalTokens === void 0 && usage.totalTokens !== void 0) {
+      totalTokens = usage.totalTokens;
+    }
+  }
+  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0) {
+    return void 0;
+  }
+  const resolvedTotalTokens = totalTokens ?? (inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0);
+  return {
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...resolvedTotalTokens !== void 0 ? { totalTokens: resolvedTotalTokens } : {}
+  };
+}
+function extractUsageFromRecord(record) {
+  const nestedResponse = record.response && typeof record.response === "object" ? record.response : void 0;
+  const candidates = [
+    record.usage,
+    nestedResponse?.usage,
+    record,
+    nestedResponse
+  ];
+  for (const candidate of candidates) {
+    const usage = parseUsageCandidate(candidate);
+    if (usage) {
+      return usage;
+    }
+  }
+  return void 0;
+}
+function parseUsageCandidate(candidate) {
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return void 0;
+  }
+  const record = candidate;
+  const inputTokens = toNumberValue(record.input_tokens) ?? toNumberValue(record.prompt_tokens) ?? toNumberValue(record.inputTokens) ?? toNumberValue(record.promptTokens);
+  const outputTokens = toNumberValue(record.output_tokens) ?? toNumberValue(record.completion_tokens) ?? toNumberValue(record.outputTokens) ?? toNumberValue(record.completionTokens);
+  const totalTokens = toNumberValue(record.total_tokens) ?? toNumberValue(record.totalTokens);
+  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0) {
+    return void 0;
+  }
+  const resolvedTotalTokens = totalTokens ?? (inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0);
+  return {
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...resolvedTotalTokens !== void 0 ? { totalTokens: resolvedTotalTokens } : {}
+  };
+}
+function parseModelIdentifier(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const slashParts = trimmed.split("/");
+  if (slashParts.length >= 2) {
+    const possibleProvider = slashParts[0]?.trim();
+    const modelPart = slashParts.slice(1).join("/").trim();
+    if (possibleProvider && modelPart) {
+      const provider = normalizeProvider(possibleProvider);
+      if (provider) {
+        return {
+          modelId: modelPart,
+          provider
+        };
+      }
+    }
+  }
+  return {
+    modelId: trimmed
+  };
+}
+function normalizeProvider(candidate) {
+  const normalized = candidate.trim().toLowerCase();
+  if (normalized.includes("openai")) {
+    return "openai";
+  }
+  if (normalized.includes("anthropic")) {
+    return "anthropic";
+  }
+  if (normalized.includes("google") || normalized.includes("gemini")) {
+    return "google";
+  }
+  return void 0;
+}
+function toTelemetryModelId(modelId) {
+  if (typeof modelId !== "string") {
+    return void 0;
+  }
+  const trimmed = modelId.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const sanitized = trimmed.replace(/[.:/\\\s]+/g, "-").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized.length > 0 ? sanitized : trimmed;
+}
+function inferProviderFromUrl(url) {
+  if (!url) {
+    return void 0;
+  }
+  const normalized = url.toLowerCase();
+  if (normalized.includes("api.openai.com")) {
+    return "openai";
+  }
+  if (normalized.includes("api.anthropic.com")) {
+    return "anthropic";
+  }
+  if (normalized.includes("generativelanguage.googleapis.com")) {
+    return "google";
+  }
+  return void 0;
+}
+function inferProviderFromModelId(modelId) {
+  if (!modelId) {
+    return void 0;
+  }
+  const normalized = modelId.toLowerCase();
+  if (normalized.startsWith("gpt-") || normalized.startsWith("o1") || normalized.startsWith("o3")) {
+    return "openai";
+  }
+  if (normalized.startsWith("claude-")) {
+    return "anthropic";
+  }
+  if (normalized.startsWith("gemini")) {
+    return "google";
+  }
+  return void 0;
+}
+function resolveActivityContext(spanProcessor, traceId) {
+  const executionContext = getOpenBoxExecutionContext();
+  if (executionContext?.activityId && executionContext.activityType && executionContext.workflowId && executionContext.workflowType && executionContext.runId) {
+    const spanActivityContext = spanProcessor.getActivityContext(
+      executionContext.workflowId,
+      executionContext.activityId
+    );
+    const spanGoal2 = toStringValue(spanActivityContext?.goal);
+    const resolvedGoal = spanGoal2 ?? executionContext.goal;
+    return {
+      activityId: executionContext.activityId,
+      ...spanActivityContext && Object.prototype.hasOwnProperty.call(spanActivityContext, "activity_input") ? {
+        activityInput: spanActivityContext.activity_input
+      } : {},
+      activityType: executionContext.activityType,
+      ...typeof resolvedGoal === "string" && resolvedGoal.length > 0 ? {
+        goal: resolvedGoal
+      } : {},
+      runId: executionContext.runId,
+      taskQueue: executionContext.taskQueue ?? "mastra",
+      workflowId: executionContext.workflowId,
+      workflowType: executionContext.workflowType,
+      ...typeof executionContext.attempt === "number" ? { attempt: executionContext.attempt } : {}
+    };
+  }
+  if (executionContext?.source === "agent" && executionContext.workflowId && executionContext.workflowType && executionContext.runId) {
+    return {
+      activityId: `${executionContext.workflowId}::agent-llm::${executionContext.runId}`,
+      activityType: "agentLlmCompletion",
+      ...executionContext.goal ? { goal: executionContext.goal } : {},
+      runId: executionContext.runId,
+      syntheticAgentActivity: true,
+      taskQueue: executionContext.taskQueue ?? "mastra",
+      workflowId: executionContext.workflowId,
+      workflowType: executionContext.workflowType,
+      ...typeof executionContext.attempt === "number" ? { attempt: executionContext.attempt } : {}
+    };
+  }
+  const spanContext = spanProcessor.getActivityContextByTrace(traceId);
+  if (!spanContext) {
+    return void 0;
+  }
+  const activityId = toStringValue(spanContext.activity_id);
+  const activityType = toStringValue(spanContext.activity_type);
+  const workflowId = toStringValue(spanContext.workflow_id);
+  const workflowType = toStringValue(spanContext.workflow_type);
+  const runId = toStringValue(spanContext.run_id);
+  if (!activityId || !activityType || !workflowId || !workflowType || !runId) {
+    return void 0;
+  }
+  const spanGoal = toStringValue(spanContext.goal);
+  return {
+    activityId,
+    activityInput: spanContext.activity_input,
+    activityType,
+    ...spanGoal ? { goal: spanGoal } : {},
+    runId,
+    taskQueue: toStringValue(spanContext.task_queue) ?? "mastra",
+    workflowId,
+    workflowType,
+    ...typeof spanContext.attempt === "number" ? { attempt: spanContext.attempt } : {}
+  };
+}
+function createHookSpan(input) {
+  const span = {
+    attributes: input.attributes,
+    events: [],
+    hook_type: input.hookType,
+    kind: input.kind,
+    name: input.name,
+    semantic_type: input.semanticType,
+    span_id: normalizeHexId(input.spanId, 16),
+    stage: input.stage,
+    start_time: input.startTimeNs,
+    status: {
+      code: input.error ? "ERROR" : "OK",
+      ...input.error ? { description: input.error } : {}
+    },
+    trace_id: normalizeHexId(input.traceId, 32)
+  };
+  if (input.stage === "completed") {
+    span.end_time = input.endTimeNs;
+    span.duration_ns = Math.max(0, input.endTimeNs - input.startTimeNs);
+  }
+  if (input.parentSpanId !== void 0) {
+    span.parent_span_id = normalizeHexId(input.parentSpanId, 16);
+  }
+  if (input.error !== void 0) {
+    span.error = input.error;
+  }
+  if (input.requestBody !== void 0) {
+    span.request_body = input.requestBody;
+  }
+  if (input.stage === "completed" && input.responseBody !== void 0) {
+    span.response_body = input.responseBody;
+  }
+  if (input.requestHeaders !== void 0) {
+    span.request_headers = input.requestHeaders;
+  }
+  if (input.stage === "completed" && input.responseHeaders !== void 0) {
+    span.response_headers = input.responseHeaders;
+  }
+  if (input.hookType === "http_request") {
+    if (input.httpMethod !== void 0) {
+      span.http_method = input.httpMethod;
+    }
+    if (input.httpUrl !== void 0) {
+      span.http_url = input.httpUrl;
+    }
+    if (input.stage === "completed" && input.httpStatusCode !== void 0) {
+      span.http_status_code = input.httpStatusCode;
+    }
+  } else if (input.hookType === "db_query") {
+    if (input.dbSystem !== void 0) {
+      span.db_system = input.dbSystem;
+    }
+    if (input.dbName !== void 0) {
+      span.db_name = input.dbName;
+    }
+    if (input.dbOperation !== void 0) {
+      span.db_operation = input.dbOperation;
+    }
+    if (input.dbStatement !== void 0) {
+      span.db_statement = input.dbStatement;
+    }
+    if (input.serverAddress !== void 0) {
+      span.server_address = input.serverAddress;
+    }
+    if (input.serverPort !== void 0) {
+      span.server_port = input.serverPort;
+    }
+    if (input.stage === "completed" && input.rowcount !== void 0) {
+      span.rowcount = input.rowcount;
+    }
+  } else if (input.hookType === "file_operation") {
+    if (input.filePath !== void 0) {
+      span.file_path = input.filePath;
+    }
+    if (input.fileMode !== void 0) {
+      span.file_mode = input.fileMode;
+    }
+    if (input.fileOperation !== void 0) {
+      span.file_operation = input.fileOperation;
+    }
+    if (input.stage === "completed" && input.data !== void 0) {
+      span.data = input.data;
+    }
+    if (input.stage === "completed" && input.bytesRead !== void 0) {
+      span.bytes_read = input.bytesRead;
+    }
+    if (input.stage === "completed" && input.bytesWritten !== void 0) {
+      span.bytes_written = input.bytesWritten;
+    }
+    if (input.stage === "completed" && input.linesCount !== void 0) {
+      span.lines_count = input.linesCount;
+    }
+  } else if (input.hookType === "function_call") {
+    if (input.functionName !== void 0) {
+      span.function = input.functionName;
+    }
+    if (input.functionModule !== void 0) {
+      span.module = input.functionModule;
+    }
+    if (input.functionArgs !== void 0) {
+      span.args = sanitizeForGovernancePayload(input.functionArgs);
+    }
+    if (input.stage === "completed" && input.functionResult !== void 0) {
+      span.result = sanitizeForGovernancePayload(input.functionResult);
+    }
+  }
+  return span;
+}
+function normalizeHexId(value, width) {
+  const base = (value ?? randomUUID().replaceAll("-", "")).toLowerCase();
+  const filtered = base.replace(/[^a-f0-9]/g, "");
+  if (filtered.length >= width) {
+    return filtered.slice(0, width);
+  }
+  return filtered.padEnd(width, "0");
+}
+function toStringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function toNumberValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function getSpanAttribute(span, key) {
+  return span.attributes?.[key];
+}
+function parseDbOperation(statement) {
+  if (!statement) {
+    return void 0;
+  }
+  const trimmed = statement.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const [operation] = trimmed.split(/\s+/);
+  return operation?.toUpperCase();
+}
+function sanitizeForGovernancePayload(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.parse(
+      JSON.stringify(value, (_key, entry) => {
+        if (typeof entry === "bigint") {
+          return entry.toString();
+        }
+        if (typeof entry === "function") {
+          return `[function ${entry.name || "anonymous"}]`;
+        }
+        if (typeof entry === "symbol") {
+          return entry.toString();
+        }
+        if (entry instanceof Error) {
+          return {
+            message: entry.message,
+            name: entry.name,
+            stack: entry.stack
+          };
+        }
+        if (entry && typeof entry === "object") {
+          if (seen.has(entry)) {
+            return "[circular]";
+          }
+          seen.add(entry);
+        }
+        return entry;
+      })
+    );
+  } catch {
+    return String(value);
+  }
+}
+function loadInstrumentation(definition, config) {
+  const require2 = createRequire(import.meta.url);
+  const moduleExports = require2(definition.moduleName);
+  const InstrumentationConstructor = moduleExports[definition.exportName];
+  if (typeof InstrumentationConstructor !== "function") {
+    throw new Error(
+      `Instrumentation export ${definition.exportName} was not found in ${definition.moduleName}`
+    );
+  }
+  return new InstrumentationConstructor(config);
+}
+export {
+  setupOpenBoxOpenTelemetry,
+  traced
+};
+//# sourceMappingURL=setup-openbox-opentelemetry.js.map