@brizz/sdk 0.1.29 → 0.1.30

package/dist/chunk-GCORRK6B.cjs

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/internal/semantic-conventions.ts
+var _api = require('@opentelemetry/api');
+var BRIZZ = "brizz";
+var PROPERTIES = "properties";
+var SESSION_ID = "session.id";
+var PROPERTIES_CONTEXT_KEY = _api.createContextKey.call(void 0, PROPERTIES);
+var SESSION_OBJECT_CONTEXT_KEY = _api.createContextKey.call(void 0, "brizz.session.object");
+var SESSION_INPUT = "brizz.session.input";
+var SESSION_OUTPUT = "brizz.session.output";
+var SESSION_INPUT_CONTEXT = "brizz.session.input.context";
+var SESSION_OUTPUT_CONTEXT = "brizz.session.output.context";
+var SESSION_SPAN_NAME = "brizz.start_session";
+var MUTE_INPUT = "mute.input";
+var MUTE_OUTPUT = "mute.output";
+var SESSION_TITLE_SPAN_NAME = "brizz.session_title";
+var SESSION_TITLE_GENERATION = "session.title_generation";
+var SESSION_TITLE = "brizz.session.title";
+var INTERRUPT_TOOLS = "brizz.internal.interrupt";
+var INTERNAL_EVENT_PREFIX = "brizz.internal.";
+var EXTERNAL_LINK_EVENT_NAME = "brizz.internal.external_link";
+var EXTERNAL_LINK_URL = "brizz.internal.external_link.url";
+var EXTERNAL_LINK_TITLE = "brizz.internal.external_link.title";
+var EXTERNAL_LINK_TYPE = "brizz.internal.external_link.type";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.__require = __require; exports.BRIZZ = BRIZZ; exports.SESSION_ID = SESSION_ID; exports.PROPERTIES_CONTEXT_KEY = PROPERTIES_CONTEXT_KEY; exports.SESSION_OBJECT_CONTEXT_KEY = SESSION_OBJECT_CONTEXT_KEY; exports.SESSION_INPUT = SESSION_INPUT; exports.SESSION_OUTPUT = SESSION_OUTPUT; exports.SESSION_INPUT_CONTEXT = SESSION_INPUT_CONTEXT; exports.SESSION_OUTPUT_CONTEXT = SESSION_OUTPUT_CONTEXT; exports.SESSION_SPAN_NAME = SESSION_SPAN_NAME; exports.MUTE_INPUT = MUTE_INPUT; exports.MUTE_OUTPUT = MUTE_OUTPUT; exports.SESSION_TITLE_SPAN_NAME = SESSION_TITLE_SPAN_NAME; exports.SESSION_TITLE_GENERATION = SESSION_TITLE_GENERATION; exports.SESSION_TITLE = SESSION_TITLE; exports.INTERRUPT_TOOLS = INTERRUPT_TOOLS; exports.INTERNAL_EVENT_PREFIX = INTERNAL_EVENT_PREFIX; exports.EXTERNAL_LINK_EVENT_NAME = EXTERNAL_LINK_EVENT_NAME; exports.EXTERNAL_LINK_URL = EXTERNAL_LINK_URL; exports.EXTERNAL_LINK_TITLE = EXTERNAL_LINK_TITLE; exports.EXTERNAL_LINK_TYPE = EXTERNAL_LINK_TYPE;

package/dist/chunk-JB6MA2RV.cjs

@@ -0,0 +1,158 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var _class;// src/internal/logger.ts
+var _api = require('@opentelemetry/api');
+var _pino = require('pino'); var _pino2 = _interopRequireDefault(_pino);
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
+  LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+var DEFAULT_LOG_LEVEL = 2 /* WARN */;
+var PinoLogger = (_class = class {
+  __init() {this._level = DEFAULT_LOG_LEVEL}
+  __init2() {this._pinoLogger = null}
+  __init3() {this.debug = (msg, ...meta) => {
+    if (this._level >= 4 /* DEBUG */) {
+      this.ensurePinoLogger().debug(this.formatMeta(meta), msg);
+    }
+  }}
+  __init4() {this.info = (msg, ...meta) => {
+    if (this._level >= 3 /* INFO */) {
+      this.ensurePinoLogger().info(this.formatMeta(meta), msg);
+    }
+  }}
+  __init5() {this.warn = (msg, ...meta) => {
+    if (this._level >= 2 /* WARN */) {
+      this.ensurePinoLogger().warn(this.formatMeta(meta), msg);
+    }
+  }}
+  __init6() {this.error = (msg, ...meta) => {
+    if (this._level >= 1 /* ERROR */) {
+      this.ensurePinoLogger().error(this.formatMeta(meta), msg);
+    }
+  }}
+  constructor() {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+    const envLevel = this.getLogLevelFromEnv();
+    this._level = envLevel;
+  }
+  /**
+   * Lazy initialization of Pino logger to ensure it's created AFTER Jest spies
+   * are set up during tests. This prevents the pino-pretty transport from
+   * bypassing stdout/stderr spies.
+   */
+  ensurePinoLogger() {
+    if (!this._pinoLogger) {
+      this._pinoLogger = _pino2.default.call(void 0, {
+        name: "Brizz",
+        level: this.logLevelToPino(this._level),
+        // Disable transport in test environment to allow proper spy capture
+        transport: this.isProduction() || this.isTest() ? void 0 : {
+          target: "pino-pretty",
+          options: {
+            singleLine: true,
+            colorize: true,
+            translateTime: "HH:MM:ss",
+            ignore: "pid,hostname",
+            messageFormat: "[{name}] {msg}"
+          }
+        }
+      });
+    }
+    return this._pinoLogger;
+  }
+  isProduction() {
+    return process.env["NODE_ENV"] === "production";
+  }
+  isTest() {
+    return process.env["NODE_ENV"] === "test";
+  }
+  getLogLevelFromEnv() {
+    const envLevel = process.env["BRIZZ_LOG_LEVEL"];
+    return envLevel ? parseLogLevel(envLevel) : DEFAULT_LOG_LEVEL;
+  }
+  logLevelToPino(level) {
+    switch (level) {
+      case 4 /* DEBUG */:
+        return "debug";
+      case 3 /* INFO */:
+        return "info";
+      case 2 /* WARN */:
+        return "warn";
+      case 1 /* ERROR */:
+        return "error";
+      default:
+        return "silent";
+    }
+  }
+  formatMeta(meta) {
+    if (meta.length === 0) {
+      return {};
+    }
+    if (meta.length === 1 && typeof meta[0] === "object" && meta[0] !== null) {
+      return meta[0];
+    }
+    return { metadata: meta };
+  }
+  setLevel(level) {
+    this._level = level;
+    if (this._pinoLogger) {
+      this._pinoLogger.level = this.logLevelToPino(level);
+    }
+  }
+  getLevel() {
+    return this._level;
+  }
+}, _class);
+function parseLogLevel(level) {
+  if (!level) {
+    return DEFAULT_LOG_LEVEL;
+  }
+  const normalizedLevel = level.toLowerCase().trim();
+  switch (normalizedLevel) {
+    case "debug":
+      return 4 /* DEBUG */;
+    case "info":
+      return 3 /* INFO */;
+    case "warn":
+    case "warning":
+      return 2 /* WARN */;
+    case "error":
+      return 1 /* ERROR */;
+    case "none":
+    case "off":
+    case "silent":
+      return 0 /* NONE */;
+    default: {
+      const numLevel = Math.trunc(Number(normalizedLevel));
+      if (!Number.isNaN(numLevel) && numLevel >= 0 && numLevel <= 4) {
+        return numLevel;
+      }
+      return DEFAULT_LOG_LEVEL;
+    }
+  }
+}
+var logger = new PinoLogger();
+function setLogLevel(level) {
+  const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
+  logger.setLevel(resolvedLevel);
+}
+function getLogLevel() {
+  return logger.getLevel();
+}
+
+// src/internal/version.ts
+function getSDKVersion() {
+  return "0.1.30";
+}
+
+
+
+
+
+
+
+
+
+exports.LogLevel = LogLevel; exports.DEFAULT_LOG_LEVEL = DEFAULT_LOG_LEVEL; exports.parseLogLevel = parseLogLevel; exports.logger = logger; exports.setLogLevel = setLogLevel; exports.getLogLevel = getLogLevel; exports.getSDKVersion = getSDKVersion;

package/dist/chunk-LTXMCGVQ.cjs

@@ -0,0 +1,90 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkGCORRK6Bcjs = require('./chunk-GCORRK6B.cjs');
+
+// src/internal/instrumentation/vercel-ai/interrupt.ts
+var _api = require('@opentelemetry/api');
+var INNER_OPERATION_IDS = /* @__PURE__ */ new Set([
+  "ai.generateText.doGenerate",
+  "ai.streamText.doStream"
+]);
+function isInnerLLMSpan(span) {
+  if (INNER_OPERATION_IDS.has(span.name)) {
+    return true;
+  }
+  const opId = span.attributes["ai.operationId"];
+  return typeof opId === "string" && INNER_OPERATION_IDS.has(opId);
+}
+var MAX_PENDING_ENTRIES = 1024;
+var pendingByParentSpanId = /* @__PURE__ */ new Map();
+function setPending(parentSpanId, value) {
+  pendingByParentSpanId.set(parentSpanId, value);
+  while (pendingByParentSpanId.size > MAX_PENDING_ENTRIES) {
+    const oldest = pendingByParentSpanId.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    pendingByParentSpanId.delete(oldest);
+  }
+}
+function extractInterruptTools(tools) {
+  if (!tools || typeof tools !== "object") {
+    return [];
+  }
+  return Object.entries(tools).filter(
+    ([, t]) => !!t && typeof t === "object" && t.needsApproval
+  ).map(([name]) => name);
+}
+function createInterruptIntegration() {
+  const onStepStart = (event) => {
+    const names = extractInterruptTools(event.tools);
+    if (names.length === 0) {
+      return;
+    }
+    const value = JSON.stringify(names);
+    const span = _api.trace.getActiveSpan();
+    if (!span) {
+      return;
+    }
+    span.setAttribute(_chunkGCORRK6Bcjs.INTERRUPT_TOOLS, value);
+    setPending(span.spanContext().spanId, value);
+  };
+  return {
+    onStepStart
+  };
+}
+var InterruptPropagator = class {
+  onStart(span, _parentContext) {
+    if (!isInnerLLMSpan(span)) {
+      return;
+    }
+    const parentSpanId = _optionalChain([span, 'access', _ => _.parentSpanContext, 'optionalAccess', _2 => _2.spanId]);
+    if (!parentSpanId) {
+      return;
+    }
+    const value = pendingByParentSpanId.get(parentSpanId);
+    if (!value) {
+      return;
+    }
+    span.setAttribute(_chunkGCORRK6Bcjs.INTERRUPT_TOOLS, value);
+    pendingByParentSpanId.delete(parentSpanId);
+  }
+  onEnd() {
+  }
+  async shutdown() {
+  }
+  async forceFlush() {
+  }
+};
+function _resetInterruptState() {
+  if (process.env["NODE_ENV"] !== "test") {
+    return;
+  }
+  pendingByParentSpanId.clear();
+}
+
+
+
+
+
+exports.createInterruptIntegration = createInterruptIntegration; exports.InterruptPropagator = InterruptPropagator; exports._resetInterruptState = _resetInterruptState;

package/dist/chunk-MWX3GIJW.js

@@ -0,0 +1,90 @@
+import {
+  INTERRUPT_TOOLS
+} from "./chunk-RORIBZEV.js";
+
+// src/internal/instrumentation/vercel-ai/interrupt.ts
+import { trace } from "@opentelemetry/api";
+var INNER_OPERATION_IDS = /* @__PURE__ */ new Set([
+  "ai.generateText.doGenerate",
+  "ai.streamText.doStream"
+]);
+function isInnerLLMSpan(span) {
+  if (INNER_OPERATION_IDS.has(span.name)) {
+    return true;
+  }
+  const opId = span.attributes["ai.operationId"];
+  return typeof opId === "string" && INNER_OPERATION_IDS.has(opId);
+}
+var MAX_PENDING_ENTRIES = 1024;
+var pendingByParentSpanId = /* @__PURE__ */ new Map();
+function setPending(parentSpanId, value) {
+  pendingByParentSpanId.set(parentSpanId, value);
+  while (pendingByParentSpanId.size > MAX_PENDING_ENTRIES) {
+    const oldest = pendingByParentSpanId.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    pendingByParentSpanId.delete(oldest);
+  }
+}
+function extractInterruptTools(tools) {
+  if (!tools || typeof tools !== "object") {
+    return [];
+  }
+  return Object.entries(tools).filter(
+    ([, t]) => !!t && typeof t === "object" && t.needsApproval
+  ).map(([name]) => name);
+}
+function createInterruptIntegration() {
+  const onStepStart = (event) => {
+    const names = extractInterruptTools(event.tools);
+    if (names.length === 0) {
+      return;
+    }
+    const value = JSON.stringify(names);
+    const span = trace.getActiveSpan();
+    if (!span) {
+      return;
+    }
+    span.setAttribute(INTERRUPT_TOOLS, value);
+    setPending(span.spanContext().spanId, value);
+  };
+  return {
+    onStepStart
+  };
+}
+var InterruptPropagator = class {
+  onStart(span, _parentContext) {
+    if (!isInnerLLMSpan(span)) {
+      return;
+    }
+    const parentSpanId = span.parentSpanContext?.spanId;
+    if (!parentSpanId) {
+      return;
+    }
+    const value = pendingByParentSpanId.get(parentSpanId);
+    if (!value) {
+      return;
+    }
+    span.setAttribute(INTERRUPT_TOOLS, value);
+    pendingByParentSpanId.delete(parentSpanId);
+  }
+  onEnd() {
+  }
+  async shutdown() {
+  }
+  async forceFlush() {
+  }
+};
+function _resetInterruptState() {
+  if (process.env["NODE_ENV"] !== "test") {
+    return;
+  }
+  pendingByParentSpanId.clear();
+}
+
+export {
+  createInterruptIntegration,
+  InterruptPropagator,
+  _resetInterruptState
+};